Example usage for org.apache.commons.pool2.impl GenericKeyedObjectPoolConfig setMaxTotal

Introduction

In this page you can find the example usage for org.apache.commons.pool2.impl GenericKeyedObjectPoolConfig setMaxTotal.

Prototype

public void setMaxTotal(int maxTotal) 

Source Link

Document

Set the value for the maxTotal configuration attribute for pools created with this configuration instance.

Usage

From source file:com.magnet.mmx.server.plugin.mmxmgmt.apns.APNSConnectionPoolImpl.java

/**
 * Lifecycle method./*from   ww  w.  java2s.  co  m*/
 * Initializes the connection pool with the default object factory and configuration.
 * @throws java.lang.IllegalStateException if the pool instance has already been initialized.
 */
public static void initialize() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxIdlePerKey(1);
    config.setMaxTotalPerKey(5);
    config.setMaxTotal(50);
    initialize(new APNSConnectionKeyedPooledObjectFactory(new OpenFireDBConnectionProvider()), config);
}

---

From source file:com.quancheng.saluki.core.grpc.GrpcEngine.java

private void initChannelPool() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotal(1000);
    config.setMaxTotalPerKey(3);//www . ja  v a  2  s. co m
    config.setBlockWhenExhausted(true);
    config.setMinIdlePerKey(3);
    config.setMaxWaitMillis(10);
    config.setNumTestsPerEvictionRun(Integer.MAX_VALUE);
    config.setTestOnBorrow(false);
    config.setTestOnReturn(false);
    config.setTestWhileIdle(false);
    config.setTimeBetweenEvictionRunsMillis(1 * 60000L);
    config.setMinEvictableIdleTimeMillis(10 * 60000L);
    config.setTestWhileIdle(false);
    this.channelPool = new GenericKeyedObjectPool<GrpcURL, Channel>(new GrpcChannelFactory(), config);
}

---

From source file:com.vmware.identity.idm.server.provider.LdapConnectionPool.java

private GenericKeyedObjectPoolConfig getGenericKeyedObjectPoolConfig(String tenantName) {
    LdapConnectionPoolConfig config = configManager.getConfiguration(tenantName);
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();

    poolConfig.setTestOnBorrow(config.getTestOnBorrow());
    poolConfig.setTimeBetweenEvictionRunsMillis(config.getEvictionInterval());
    poolConfig.setMinEvictableIdleTimeMillis(config.getIdleTime());
    poolConfig.setMaxTotal(config.getMaxConnections());
    poolConfig.setMaxTotalPerKey(config.getMaxConnectionsPerKey());
    poolConfig.setMaxWaitMillis(config.getMaxWaitMilis());

    return poolConfig;
}

---

From source file:com.magnet.mmx.server.plugin.mmxmgmt.MMXPlugin.java

public void initializeAPNSConnectionPool() {

    MMXConfiguration configuration = MMXConfiguration.getConfiguration();
    int maxObjectsPerKey = configuration.getInt(MMXConfigKeys.APNS_POOL_MAX_CONNECTIONS_PER_APP,
            MMXServerConstants.APNS_POOL_MAX_CONNECTIONS_PER_APP);
    int maxIdleObjectsPerKey = configuration.getInt(MMXConfigKeys.APNS_POOL_MAX_IDLE_CONNECTIONS_PER_APP,
            MMXServerConstants.APNS_POOL_MAX_IDLE_CONNECTIONS_PER_APP);
    int ttlForIdleObjectsInMinutes = configuration.getInt(MMXConfigKeys.APNS_POOL_IDLE_TTL_MINUTES,
            MMXServerConstants.APNS_POOL_IDLE_TTL_MINUTES);
    int maxTotal = configuration.getInt(MMXConfigKeys.APNS_POOL_MAX_TOTAL_CONNECTIONS,
            MMXServerConstants.APNS_POOL_MAX_TOTAL_CONNECTIONS);

    Log.info(//from   w w  w .ja  v  a2  s  .c om
            "Configuring APNS Connection pool with following values: maxObjects:{}, maxObjectsPerKey:{}, "
                    + "maxIdleObjectsPerKey:{}, ttlForIdleObjectsInMinutes:{}",
            maxTotal, maxObjectsPerKey, maxIdleObjectsPerKey, ttlForIdleObjectsInMinutes);

    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotalPerKey(maxObjectsPerKey);
    config.setMaxTotal(maxTotal);
    config.setMaxIdlePerKey(maxIdleObjectsPerKey);
    config.setMinEvictableIdleTimeMillis(ttlForIdleObjectsInMinutes * 60 * 1000L);

    APNSConnectionPoolImpl.initialize(config);
}

---

From source file:com.streamsets.datacollector.stagelibrary.ClassLoaderStageLibraryTask.java

@Override
public void initTask() {
    super.initTask();
    stageClassLoaders = runtimeInfo.getStageLibraryClassLoaders();
    if (!stageClassLoaders.isEmpty()) {
        resolveClassLoaderMethods(stageClassLoaders.get(0));
    }/*from  w  w w . java  2s.  com*/
    json = ObjectMapperFactory.get();
    stageList = new ArrayList<>();
    stageMap = new HashMap<>();
    loadStages();
    stageList = ImmutableList.copyOf(stageList);
    stageMap = ImmutableMap.copyOf(stageMap);

    // localization cache for definitions
    localizedStageList = CacheBuilder.newBuilder().build(new CacheLoader<Locale, List<StageDefinition>>() {
        @Override
        public List<StageDefinition> load(Locale key) throws Exception {
            List<StageDefinition> list = new ArrayList<>();
            for (StageDefinition stage : stageList) {
                list.add(stage.localize());
            }
            return list;
        }
    });
    validateStageVersions(stageList);

    // initializing the list of targets that can be used for error handling
    ErrorHandlingChooserValues.setErrorHandlingOptions(this);

    // initializing the list of targets that can be used as aggregating sink
    StatsTargetChooserValues.setStatsTargetOptions(this);

    // initializing the pool of private stage classloaders
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setJmxEnabled(false);
    poolConfig.setMaxTotal(
            configuration.get(MAX_PRIVATE_STAGE_CLASS_LOADERS_KEY, MAX_PRIVATE_STAGE_CLASS_LOADERS_DEFAULT));
    poolConfig.setMinEvictableIdleTimeMillis(-1);
    poolConfig.setNumTestsPerEvictionRun(0);
    poolConfig.setMaxIdlePerKey(-1);
    poolConfig.setMinIdlePerKey(0);
    poolConfig.setMaxTotalPerKey(-1);
    poolConfig.setBlockWhenExhausted(false);
    poolConfig.setMaxWaitMillis(0);
    privateClassLoaderPool = new GenericKeyedObjectPool<>(new ClassLoaderFactory(stageClassLoaders),
            poolConfig);
}

---

From source file:JDBCPool.dbcp.demo.sourcecode.PoolableConnectionFactory.java

/**
 * ?PoolDefaultPooledObject??Connection//  w  w  w  . j ava 2s  .  c o m
 */
@Override
public PooledObject<PoolableConnection> makeObject() throws Exception {
    Connection conn = _connFactory.createConnection();
    if (conn == null) {
        throw new IllegalStateException("Connection factory returned null from createConnection");
    }

    try {
        initializeConnection(conn); //?SQL?SQL
    } catch (SQLException sqle) {
        // Make sure the connection is closed
        try {
            conn.close();
        } catch (SQLException ignore) {
            // ignore
        }
        // Rethrow original exception so it is visible to caller
        throw sqle;
    }

    long connIndex = connectionIndex.getAndIncrement();

    if (poolStatements) {
        conn = new PoolingConnection(conn);
        GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
        config.setMaxTotalPerKey(-1);
        config.setBlockWhenExhausted(false);
        config.setMaxWaitMillis(0);
        config.setMaxIdlePerKey(1);
        config.setMaxTotal(maxOpenPreparedStatements);
        if (dataSourceJmxName != null) {
            StringBuilder base = new StringBuilder(dataSourceJmxName.toString());
            base.append(Constants.JMX_CONNECTION_BASE_EXT);
            base.append(Long.toString(connIndex));
            config.setJmxNameBase(base.toString());
            config.setJmxNamePrefix(Constants.JMX_STATEMENT_POOL_PREFIX);
        } else {
            config.setJmxEnabled(false);
        }
        KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> stmtPool = new GenericKeyedObjectPool<>(
                (PoolingConnection) conn, config);
        ((PoolingConnection) conn).setStatementPool(stmtPool);
        ((PoolingConnection) conn).setCacheState(_cacheState);
    }

    // Register this connection with JMX
    ObjectName connJmxName;
    if (dataSourceJmxName == null) {
        connJmxName = null;
    } else {
        connJmxName = new ObjectName(
                dataSourceJmxName.toString() + Constants.JMX_CONNECTION_BASE_EXT + connIndex);
    }

    PoolableConnection pc = new PoolableConnection(conn, _pool, connJmxName, _disconnectionSqlCodes,
            _fastFailValidation);

    return new DefaultPooledObject<>(pc);
}

---

From source file:com.google.devtools.build.lib.worker.WorkerModule.java

@Override
public void beforeCommand(Command command, CommandEnvironment env) {
    this.env = env;
    env.getEventBus().register(this);

    if (workers == null) {
        Path logDir = env.getRuntime().getOutputBase().getRelative("worker-logs");
        try {/*  w w w.j a  v  a2 s  .c  o m*/
            logDir.createDirectory();
        } catch (IOException e) {
            env.getReporter().handle(Event.error("Could not create directory for worker logs: " + logDir));
        }

        GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();

        // It's better to re-use a worker as often as possible and keep it hot, in order to profit
        // from JIT optimizations as much as possible.
        config.setLifo(true);

        // Check for & deal with idle workers every 5 seconds.
        config.setTimeBetweenEvictionRunsMillis(5 * 1000);

        // Always test the liveliness of worker processes.
        config.setTestOnBorrow(true);
        config.setTestOnCreate(true);
        config.setTestOnReturn(true);
        config.setTestWhileIdle(true);

        // Don't limit the total number of worker processes, as otherwise the pool might be full of
        // e.g. Java workers and could never accommodate another request for a different kind of
        // worker.
        config.setMaxTotal(-1);

        workers = new WorkerPool(new WorkerFactory(), config);
        workers.setReporter(env.getReporter());
        workers.setLogDirectory(logDir);
    }
}

---

From source file:org.apache.jmeter.visualizers.backend.graphite.AbstractGraphiteMetricsSender.java

/**
 * Create a new keyed pool of {@link SocketOutputStream}s using a
 * {@link SocketOutputStreamPoolFactory}. The keys for the pool are
 * {@link SocketConnectionInfos} instances.
 *
 * @return GenericKeyedObjectPool the newly generated pool
 *//*from w ww  .  j  av  a 2  s . c o  m*/
protected GenericKeyedObjectPool<SocketConnectionInfos, SocketOutputStream> createSocketOutputStreamPool() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setTestOnBorrow(true);
    config.setTestWhileIdle(true);
    config.setMaxTotalPerKey(-1);
    config.setMaxTotal(-1);
    config.setMaxIdlePerKey(-1);
    config.setMinEvictableIdleTimeMillis(TimeUnit.MINUTES.toMillis(3));
    config.setTimeBetweenEvictionRunsMillis(TimeUnit.MINUTES.toMillis(3));

    return new GenericKeyedObjectPool<>(
            new SocketOutputStreamPoolFactory(SOCKET_CONNECT_TIMEOUT_MS, SOCKET_TIMEOUT), config);
}

---

From source file:org.apache.sentry.core.common.transport.SentryTransportPool.java

/**
 * Configure transport pool.//from www.j  av a 2s.c o m
 * <p>
 * The pool accepts the following configuration:
 * <ul>
 *   <li>Maximum total number of objects in the pool</li>
 *   <li>Minimum number of idle objects</li>
 *   <li>Maximum number of idle objects</li>
 *   <li>Minimum time before the object is evicted</li>
 *   <li>Interval between evictions</li>
 * </ul>
 * @param conf Configuration
 * @param transportConfig Configuration interface
 * @param transportFactory Transport factory used to produce transports
 */
public SentryTransportPool(Configuration conf, SentryClientTransportConfigInterface transportConfig,
        TransportFactory transportFactory) {

    // This isn't thread-safe, but we don't care - it is only used
    // for debugging when running tests - normal apps use a single pool
    poolId++;
    id = poolId;

    this.transportFactory = transportFactory;
    doLoadBalancing = transportConfig.isLoadBalancingEnabled(conf);
    isPoolEnabled = transportConfig.isTransportPoolEnabled(conf);

    // Get list of server addresses
    String hostsAndPortsStr = transportConfig.getSentryServerRpcAddress(conf);
    int serverPort = transportConfig.getServerRpcPort(conf);
    LOGGER.info("Creating pool for {} with default port {}", hostsAndPortsStr, serverPort);
    String[] hostsAndPortsStrArr = hostsAndPortsStr.split(",");
    Preconditions.checkArgument(hostsAndPortsStrArr.length > 0, "At least one server should be specified");

    endpoints = new ArrayList<>(hostsAndPortsStrArr.length);
    for (String addr : hostsAndPortsStrArr) {
        HostAndPort endpoint = ThriftUtil.parseAddress(addr, serverPort);
        LOGGER.info("Adding endpoint {}", endpoint);
        endpoints.add(endpoint);
    }

    if (!isPoolEnabled) {
        pool = null;
        LOGGER.info("Connection pooling is disabled");
        return;
    }

    LOGGER.info("Connection pooling is enabled");
    // Set pool configuration based on Configuration settings
    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();

    // Don't limit maximum number of objects in the pool
    poolConfig.setMaxTotal(-1);

    poolConfig.setMinIdlePerKey(transportConfig.getPoolMinIdle(conf));
    poolConfig.setMaxIdlePerKey(transportConfig.getPoolMaxIdle(conf));

    // Do not block when pool is exhausted, throw exception instead
    poolConfig.setBlockWhenExhausted(false);
    poolConfig.setTestOnReturn(true);

    // No limit for total objects in the pool
    poolConfig.setMaxTotalPerKey(transportConfig.getPoolMaxTotal(conf));
    poolConfig.setMinEvictableIdleTimeMillis(transportConfig.getMinEvictableTimeSec(conf));
    poolConfig.setTimeBetweenEvictionRunsMillis(transportConfig.getTimeBetweenEvictionRunsSec(conf));

    // Create object pool
    pool = new GenericKeyedObjectPool<>(new PoolFactory(this.transportFactory, id), poolConfig);
}

---

From source file:org.jmxtrans.embedded.output.GraphitePickleWriter.java

/**
 * Load settings, initialize the {@link SocketWriter} pool and test the connection to the graphite server.
 *
 * a {@link Logger#warn(String)} message is emitted if the connection to the graphite server fails.
 *//* w  ww .  j a  va2s  .c o  m*/
@Override
public void start() {
    int port = getIntSetting(SETTING_PORT, DEFAULT_GRAPHITE_SERVER_PORT);
    String host = getStringSetting(SETTING_HOST);
    graphiteServerHostAndPort = new HostAndPort(host, port);

    logger.info("Start Graphite Pickle writer connected to '{}'...", graphiteServerHostAndPort);

    metricPathPrefix = getStringSetting(SETTING_NAME_PREFIX, DEFAULT_NAME_PREFIX);
    metricPathPrefix = getStrategy().resolveExpression(metricPathPrefix);
    if (!metricPathPrefix.isEmpty() && !metricPathPrefix.endsWith(".")) {
        metricPathPrefix = metricPathPrefix + ".";
    }

    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setTestOnBorrow(getBooleanSetting("pool.testOnBorrow", true));
    config.setTestWhileIdle(getBooleanSetting("pool.testWhileIdle", true));
    config.setMaxTotal(getIntSetting("pool.maxActive", -1));
    config.setMaxIdlePerKey(getIntSetting("pool.maxIdle", -1));
    config.setMinEvictableIdleTimeMillis(
            getLongSetting("pool.minEvictableIdleTimeMillis", TimeUnit.MINUTES.toMillis(5)));
    config.setTimeBetweenEvictionRunsMillis(
            getLongSetting("pool.timeBetweenEvictionRunsMillis", TimeUnit.MINUTES.toMillis(5)));
    config.setJmxNameBase(
            "org.jmxtrans.embedded:type=GenericKeyedObjectPool,writer=GraphitePickleWriter,name=");
    config.setJmxNamePrefix(graphiteServerHostAndPort.getHost() + "_" + graphiteServerHostAndPort.getPort());

    int socketConnectTimeoutInMillis = getIntSetting("graphite.socketConnectTimeoutInMillis",
            SocketOutputStreamPoolFactory.DEFAULT_SOCKET_CONNECT_TIMEOUT_IN_MILLIS);

    socketOutputStreamPool = new GenericKeyedObjectPool<HostAndPort, SocketOutputStream>(
            new SocketOutputStreamPoolFactory(socketConnectTimeoutInMillis), config);

    if (isEnabled()) {
        try {
            SocketOutputStream socketOutputStream = socketOutputStreamPool
                    .borrowObject(graphiteServerHostAndPort);
            socketOutputStreamPool.returnObject(graphiteServerHostAndPort, socketOutputStream);
        } catch (Exception e) {
            logger.warn("Test Connection: FAILURE to connect to Graphite server '{}'",
                    graphiteServerHostAndPort, e);
        }
    }
    try {
        Class.forName("org.python.modules.cPickle");
    } catch (ClassNotFoundException e) {
        throw new EmbeddedJmxTransException("jython librarie is required by the " + getClass().getSimpleName()
                + " but is not found in the classpath. Please add org.python:jython:2.5.3+ to the classpath.");
    }
}

---

• «
• 1
• 2
• »