Examples with PoolFactory org.apache.geode.cache.client.PoolFactory used on opensource projects

Example 41 with PoolFactory

use of org.apache.geode.cache.client.PoolFactory in project geode by apache.

the class CacheXmlParser method doServer.

/**
   * @since GemFire 5.7
   */
private void doServer(Attributes atts) {
    PoolFactory f = (PoolFactory) stack.peek();
    String host = atts.getValue(HOST).trim();
    int port = parseInt(atts.getValue(PORT));
    f.addServer(host, port);
}

Example 42 with PoolFactory

use of org.apache.geode.cache.client.PoolFactory in project geode by apache.

the class ConnectionPoolFactoryJUnitTest method testCreateDefaultAndInvalidAndLegitAttributes.

@Test
public void testCreateDefaultAndInvalidAndLegitAttributes() {
    PoolFactory cpf = PoolManager.createFactory();
    ((PoolFactoryImpl) cpf).setStartDisabled(true);
    try {
        cpf.create("illegal");
        fail("expected IllegalStateException");
    } catch (IllegalStateException expected) {
    }
    cpf.addServer("localhost", 40907);
    Pool defaultAttr = cpf.create("defaults");
    try {
        // now add a source and try defaults again
        assertEquals(PoolFactory.DEFAULT_FREE_CONNECTION_TIMEOUT, defaultAttr.getFreeConnectionTimeout());
        assertEquals(PoolFactory.DEFAULT_THREAD_LOCAL_CONNECTIONS, defaultAttr.getThreadLocalConnections());
        assertEquals(PoolFactory.DEFAULT_READ_TIMEOUT, defaultAttr.getReadTimeout());
        assertEquals(PoolFactory.DEFAULT_MIN_CONNECTIONS, defaultAttr.getMinConnections());
        assertEquals(PoolFactory.DEFAULT_MAX_CONNECTIONS, defaultAttr.getMaxConnections());
        assertEquals(PoolFactory.DEFAULT_RETRY_ATTEMPTS, defaultAttr.getRetryAttempts());
        assertEquals(PoolFactory.DEFAULT_IDLE_TIMEOUT, defaultAttr.getIdleTimeout());
        assertEquals(PoolFactory.DEFAULT_PING_INTERVAL, defaultAttr.getPingInterval());
        assertEquals(PoolFactory.DEFAULT_SOCKET_BUFFER_SIZE, defaultAttr.getSocketBufferSize());
    } finally {
        defaultAttr.destroy();
    }
    /*
     * Lets configure each attribute and make sure they are reflected in the attributes
     */
    int connectionTimeout = -1;
    int connectionLifetime = -2;
    boolean threadLocalConnections = false;
    int readTimeout = -1;
    int messageTrackingTimeout = -1;
    int ackInterval = -1;
    int minConnections = -1;
    int maxConnections = -2;
    int retryAttempts = -2;
    int pingInterval = -1;
    int idleTimeout = -2;
    int redundancy = -2;
    int bufferSize = -1;
    /* All of these should fail */
    try {
        cpf.setFreeConnectionTimeout(connectionTimeout);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setLoadConditioningInterval(connectionLifetime);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setReadTimeout(readTimeout);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setMinConnections(minConnections);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setMaxConnections(maxConnections);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setRetryAttempts(retryAttempts);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setPingInterval(pingInterval);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setIdleTimeout(idleTimeout);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setIdleTimeout(idleTimeout);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setSocketBufferSize(bufferSize);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setSubscriptionRedundancy(redundancy);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setSubscriptionMessageTrackingTimeout(messageTrackingTimeout);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    try {
        cpf.setSubscriptionAckInterval(ackInterval);
        assertTrue("This should have failed with IllegalArgumentException", false);
    } catch (IllegalArgumentException iae) {
    // this is what we want
    }
    /* none of those should take effect so this should still match default */
    defaultAttr = cpf.create("default");
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getFreeConnectionTimeout(), PoolFactory.DEFAULT_FREE_CONNECTION_TIMEOUT);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getLoadConditioningInterval(), PoolFactory.DEFAULT_LOAD_CONDITIONING_INTERVAL);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getThreadLocalConnections(), PoolFactory.DEFAULT_THREAD_LOCAL_CONNECTIONS);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getReadTimeout(), PoolFactory.DEFAULT_READ_TIMEOUT);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getMinConnections(), PoolFactory.DEFAULT_MIN_CONNECTIONS);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getMaxConnections(), PoolFactory.DEFAULT_MAX_CONNECTIONS);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getRetryAttempts(), PoolFactory.DEFAULT_RETRY_ATTEMPTS);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getIdleTimeout(), PoolFactory.DEFAULT_IDLE_TIMEOUT);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getPingInterval(), PoolFactory.DEFAULT_PING_INTERVAL);
    assertEquals("Attribute should match default, but doesn't", defaultAttr.getSocketBufferSize(), PoolFactory.DEFAULT_SOCKET_BUFFER_SIZE);
    /* Lets do a legitimate one now */
    connectionTimeout = 30;
    connectionLifetime = -1;
    threadLocalConnections = true;
    readTimeout = 3;
    minConnections = 6;
    maxConnections = 7;
    retryAttempts = 2;
    pingInterval = 23;
    idleTimeout = 14;
    messageTrackingTimeout = 40;
    ackInterval = 33;
    redundancy = 4;
    bufferSize = 1000;
    cpf.setFreeConnectionTimeout(connectionTimeout);
    cpf.setLoadConditioningInterval(connectionLifetime);
    cpf.setThreadLocalConnections(threadLocalConnections);
    cpf.setReadTimeout(readTimeout);
    cpf.setSubscriptionEnabled(true);
    cpf.setSubscriptionRedundancy(redundancy);
    cpf.setSubscriptionMessageTrackingTimeout(messageTrackingTimeout);
    cpf.setSubscriptionAckInterval(ackInterval);
    cpf.setMinConnections(minConnections);
    cpf.setMaxConnections(maxConnections);
    cpf.setRetryAttempts(retryAttempts);
    cpf.setPingInterval(pingInterval);
    cpf.setIdleTimeout(idleTimeout);
    cpf.setSocketBufferSize(bufferSize);
    Pool cpa = cpf.create("mypool");
    try {
        assertEquals(connectionTimeout, cpa.getFreeConnectionTimeout());
        assertEquals(connectionLifetime, cpa.getLoadConditioningInterval());
        assertEquals(threadLocalConnections, cpa.getThreadLocalConnections());
        assertEquals(true, cpa.getSubscriptionEnabled());
        assertEquals(redundancy, cpa.getSubscriptionRedundancy());
        assertEquals(messageTrackingTimeout, cpa.getSubscriptionMessageTrackingTimeout());
        assertEquals(readTimeout, cpa.getReadTimeout());
        assertEquals(minConnections, cpa.getMinConnections());
        assertEquals(maxConnections, cpa.getMaxConnections());
        assertEquals(ackInterval, cpa.getSubscriptionAckInterval());
        assertEquals(retryAttempts, cpa.getRetryAttempts());
        assertEquals(idleTimeout, cpa.getIdleTimeout());
        assertEquals(pingInterval, cpa.getPingInterval());
        assertEquals(bufferSize, cpa.getSocketBufferSize());
        // validate contacts
        assertEquals(1, cpa.getServers().size());
        assertEquals(0, cpa.getLocators().size());
    } finally {
        cpa.destroy();
    }
    // test reset
    cpf.reset();
    try {
        cpf.create("mypool");
        fail("expected IllegalStateException");
    } catch (IllegalStateException expected) {
    // since reset emptied out the contacts
    }
}

Example 43 with PoolFactory

use of org.apache.geode.cache.client.PoolFactory in project geode by apache.

the class ConnectionPoolImplJUnitTest method testCacheClose.

@Test
public void testCacheClose() throws Exception {
    PoolFactory cpf = PoolManager.createFactory();
    cpf.addLocator("localhost", AvailablePortHelper.getRandomAvailableTCPPort());
    Pool pool1 = cpf.create("pool1");
    Pool pool2 = cpf.create("pool2");
    cache.close();
    assertTrue(pool1.isDestroyed());
    assertTrue(pool2.isDestroyed());
}

Example 44 with PoolFactory

use of org.apache.geode.cache.client.PoolFactory in project geode by apache.

the class ConnectionPoolImplJUnitTest method testProperties.

@Test
public void testProperties() throws Exception {
    int readTimeout = 234234;
    PoolFactory cpf = PoolManager.createFactory();
    cpf.addServer("localhost", port).setReadTimeout(readTimeout).setThreadLocalConnections(true);
    PoolImpl pool = (PoolImpl) cpf.create("myfriendlypool");
    // check non default
    assertEquals("myfriendlypool", pool.getName());
    assertEquals(readTimeout, pool.getReadTimeout());
    assertEquals(true, pool.getThreadLocalConnections());
    assertEquals(1, pool.getServers().size());
    assertEquals(0, pool.getLocators().size());
    {
        InetSocketAddress addr = (InetSocketAddress) pool.getServers().get(0);
        assertEquals(port, addr.getPort());
        assertEquals("localhost", addr.getHostName());
    }
    LiveServerPinger lsp = new LiveServerPinger(pool);
    long NANOS_PER_MS = 1000000L;
    assertEquals(((pool.getPingInterval() + 1) / 2) * NANOS_PER_MS, lsp.pingIntervalNanos);
}

Example 45 with PoolFactory

use of org.apache.geode.cache.client.PoolFactory in project geode by apache.

the class Tomcat8SessionsClientServerDUnitTest method setupServer.

// Set up the servers we need
public void setupServer(DeltaSessionManager manager) throws Exception {
    Host host = Host.getHost(0);
    vm0 = host.getVM(1);
    String hostName = vm0.getHost().getHostName();
    int cacheServerPort = vm0.invoke(() -> {
        Properties props = new Properties();
        CacheFactory cf = new CacheFactory(props);
        Cache cache = cf.create();
        CacheServer server = cache.addCacheServer();
        server.start();
        return server.getPort();
    });
    port = AvailablePortHelper.getRandomAvailableTCPPort();
    server = new EmbeddedTomcat8("/test", port, "JVM-1");
    ClientServerCacheLifecycleListener listener = new ClientServerCacheLifecycleListener();
    listener.setProperty(MCAST_PORT, "0");
    listener.setProperty(LOG_LEVEL, "config");
    server.addLifecycleListener(listener);
    sessionManager = manager;
    sessionManager.setEnableCommitValve(true);
    server.getRootContext().setManager(sessionManager);
    servlet = server.addServlet("/test/*", "default", CommandServlet.class.getName());
    server.startContainer();
    PoolFactory pf = PoolManager.createFactory();
    pf.addServer(hostName, cacheServerPort);
    pf.create("Pool Connecting to Cache Server");
    /*
     * Can only retrieve the region once the container has started up (and the cache has started
     * too).
     */
    region = sessionManager.getSessionCache().getSessionRegion();
    sessionManager.getTheContext().setSessionTimeout(30);
}