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

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

Introduction

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

Prototype

public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) 

Source Link

Document

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

Usage

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

@BeforeClass
public static void setUp() throws Exception {
    LOGGER.info("Setting up the pool");
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotalPerKey(MAX_OBJECTS_PER_KEY);
    config.setMaxIdlePerKey(3);/*from   w  ww .ja va2  s .co m*/
    config.setMinEvictableIdleTimeMillis(10 * 60 * 1000L);
    config.setTimeBetweenEvictionRunsMillis(1000L);
    objectFactory = new StubAPNSConnectionKeyedPooledObjectFactory(appWithBadCert);
    APNSConnectionPoolImpl.initialize(objectFactory, 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.j a va 2 s  .c o m
            "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.quancheng.saluki.core.grpc.GrpcEngine.java

private void initChannelPool() {
    GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
    config.setMaxTotal(1000);/*ww w. j a  va 2  s  .c  o 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:com.streamsets.datacollector.stagelibrary.ClassLoaderStageLibraryTask.java

@Override
public void initTask() {
    super.initTask();
    stageClassLoaders = runtimeInfo.getStageLibraryClassLoaders();
    if (!stageClassLoaders.isEmpty()) {
        resolveClassLoaderMethods(stageClassLoaders.get(0));
    }// w  ww  .  j a va2 s . c  om
    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.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  w w.ja  va 2s. c om*/
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  w ww  .jav  a  2 s. co 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  av a 2 s .co  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.");
    }
}

From source file:org.jmxtrans.embedded.output.GraphiteWriter.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.
 *///from  w  ww  . j  a  v  a 2  s  .  com
@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 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=GraphiteWriter,name=");
    config.setJmxNamePrefix(graphiteServerHostAndPort.getHost() + "_" + graphiteServerHostAndPort.getPort());

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

    String protocol = getStringSetting(SETTING_PROTOCOL, null);
    if (protocol != null && protocol.equalsIgnoreCase(PROTOCOL_UDP)) {
        socketWriterPool = new GenericKeyedObjectPool<HostAndPort, SocketWriter>(
                new UDPSocketWriterPoolFactory(StandardCharsets.UTF_8), config);
    } else {
        if (protocol == null) {
            // protocol not specified, use default one
            logger.info("Protocol unspecified, default protocol '{}' will be used.", PROTOCOL_TCP);
        } else if (PROTOCOL_TCP.equalsIgnoreCase(protocol) == false) {
            // unknown or protocol, use default one
            logger.warn("Unknown protocol specified '{}', default protocol '{}' will be used instead.",
                    protocol, PROTOCOL_TCP);
        }
        socketWriterPool = new GenericKeyedObjectPool<HostAndPort, SocketWriter>(
                new SocketWriterPoolFactory(StandardCharsets.UTF_8, socketConnectTimeoutInMillis), config);
    }

    if (isEnabled()) {
        try {
            SocketWriter socketWriter = socketWriterPool.borrowObject(graphiteServerHostAndPort);
            socketWriterPool.returnObject(graphiteServerHostAndPort, socketWriter);
        } catch (Exception e) {
            logger.warn("Test Connection: FAILURE to connect to Graphite server '{}'",
                    graphiteServerHostAndPort, e);
        }
    }
}

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;
}