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

List of usage examples for org.apache.commons.pool2.impl GenericKeyedObjectPoolConfig setMinIdlePerKey

Introduction

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

Prototype

public void setMinIdlePerKey(int minIdlePerKey) 

Source Link

Document

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

Usage

From source file:io.mandrel.transport.thrift.ThriftClients.java

@PostConstruct
public void init() {

    GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setMaxTotalPerKey(4);/*w w  w . j av  a 2s  .co m*/
    poolConfig.setMinIdlePerKey(1);

    ThriftCatalog catalog = new ThriftCatalog();
    catalog.addDefaultCoercions(MandrelCoercions.class);
    ThriftCodecManager codecManager = new ThriftCodecManager(
            new CompilerThriftCodecFactory(ThriftCodecManager.class.getClassLoader()), catalog,
            Collections.emptySet());

    NettyClientConfig config = NettyClientConfig.newBuilder().build();
    NiftyClient niftyClient = new NiftyClient(config, local);
    ThriftClientManager clientManager = new ThriftClientManager(codecManager, niftyClient,
            Collections.emptySet());

    frontiers = new KeyedClientPool<>(FrontierContract.class, poolConfig, 9090,
            // Deflater.BEST_SPEED
            null, clientManager);
    prepare(frontiers);

    controllers = new KeyedClientPool<>(ControllerContract.class, poolConfig, 9090,
            // Deflater.BEST_SPEED
            null, clientManager);
    prepare(controllers);

    workers = new KeyedClientPool<>(WorkerContract.class, poolConfig, 9090,
            // Deflater.BEST_SPEED
            null, clientManager);
    prepare(workers);

    nodes = new KeyedClientPool<>(NodeContract.class, poolConfig, 9090,
            // Deflater.BEST_SPEED
            null, clientManager);
    prepare(nodes);
}

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

private void initChannelPool() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotal(1000);// w w w .  j  a v  a2  s.  co  m
    config.setMaxTotalPerKey(3);
    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:net.sheehantech.cherry.pool.KeyedPooledPushClient.java

@Override
public void init() throws ConnectionFailedException {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    if (maxTotal != null)
        config.setMaxTotalPerKey(maxTotal);
    if (maxIdle != null)
        config.setMaxIdlePerKey(maxIdle);
    if (minIdle != null)
        config.setMinIdlePerKey(minIdle);
    config.setTestOnBorrow(true);/*w w  w  . j  a  va  2 s  .c om*/
    config.setTestWhileIdle(true);
    config.setBlockWhenExhausted(true);
    config.setMaxTotalPerKey(maxTotal);
    pool = new GenericKeyedObjectPool<K, PooledPushSocket>(
            new KeyedPooledPushSocketFactory(socketFactories, gateways, ports), config);
    try {
        for (K k : sslContexts.keySet())
            pool.preparePool(k);
    } catch (Exception e) {
        throw (new ConnectionFailedException(e));
    }
    logger.debug("Started new push socket pool with {} sockets", pool.getNumIdle());

}

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   ww  w  . j  av  a 2  s  .c o m
    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:org.apache.sentry.core.common.transport.SentryTransportPool.java

/**
 * Configure transport pool.//from   ww w. ja v a  2 s  .  com
 * <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.springframework.ldap.pool2.factory.PooledContextSource.java

private GenericKeyedObjectPoolConfig getConfig(PoolConfig poolConfig) {
    GenericKeyedObjectPoolConfig objectPoolConfig = new GenericKeyedObjectPoolConfig();

    objectPoolConfig.setMaxTotalPerKey(poolConfig.getMaxTotalPerKey());
    objectPoolConfig.setMaxTotal(poolConfig.getMaxTotal());

    objectPoolConfig.setMaxIdlePerKey(poolConfig.getMaxIdlePerKey());
    objectPoolConfig.setMinIdlePerKey(poolConfig.getMinIdlePerKey());

    objectPoolConfig.setTestWhileIdle(poolConfig.isTestWhileIdle());
    objectPoolConfig.setTestOnReturn(poolConfig.isTestOnReturn());
    objectPoolConfig.setTestOnCreate(poolConfig.isTestOnCreate());
    objectPoolConfig.setTestOnBorrow(poolConfig.isTestOnBorrow());

    objectPoolConfig.setTimeBetweenEvictionRunsMillis(poolConfig.getTimeBetweenEvictionRunsMillis());
    objectPoolConfig.setEvictionPolicyClassName(poolConfig.getEvictionPolicyClassName());
    objectPoolConfig.setMinEvictableIdleTimeMillis(poolConfig.getMinEvictableIdleTimeMillis());
    objectPoolConfig.setNumTestsPerEvictionRun(poolConfig.getNumTestsPerEvictionRun());
    objectPoolConfig.setSoftMinEvictableIdleTimeMillis(poolConfig.getSoftMinEvictableIdleTimeMillis());

    objectPoolConfig.setJmxEnabled(poolConfig.isJmxEnabled());
    objectPoolConfig.setJmxNameBase(poolConfig.getJmxNameBase());
    objectPoolConfig.setJmxNamePrefix(poolConfig.getJmxNamePrefix());

    objectPoolConfig.setMaxWaitMillis(poolConfig.getMaxWaitMillis());

    objectPoolConfig.setFairness(poolConfig.isFairness());
    objectPoolConfig.setBlockWhenExhausted(poolConfig.isBlockWhenExhausted());
    objectPoolConfig.setLifo(poolConfig.isLifo());

    return objectPoolConfig;
}