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

Example 16 with ServerOperationException

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

the class PutAllCSDUnitTest method testPartialKeyInPRSingleHop.

/**
   * Tests partial key putAll to 2 PR servers, because putting data at server side is different
   * between PR and LR. PR does it in postPutAll. This is a singlehop putAll test.
   */
@Test
public void testPartialKeyInPRSingleHop() throws CacheException, InterruptedException {
    final String title = "testPartialKeyInPRSingleHop_";
    final int cacheWriterAllowedKeyNum = 16;
    final Host host = Host.getHost(0);
    final VM server1 = host.getVM(0);
    final VM server2 = host.getVM(1);
    final VM client1 = host.getVM(2);
    final VM client2 = host.getVM(3);
    final String regionName = getUniqueName();
    final String serverHost = NetworkUtils.getServerHostName(server1.getHost());
    // set <true, false> means <PR=true, notifyBySubscription=false> to test local-invalidates
    final int serverPort1 = createBridgeServer(server1, regionName, 0, true, 0, "ds1");
    final int serverPort2 = createBridgeServer(server2, regionName, 0, true, 0, "ds1");
    createClient(client1, regionName, serverHost, new int[] { serverPort1, serverPort2 }, -1, -1, false, false, true, false);
    createClient(client2, regionName, serverHost, new int[] { serverPort1, serverPort2 }, -1, -1, false, false, true);
    server1.invoke(addExceptionTag1(expectedExceptions));
    server2.invoke(addExceptionTag1(expectedExceptions));
    client1.invoke(addExceptionTag1(expectedExceptions));
    client2.invoke(addExceptionTag1(expectedExceptions));
    try {
        client2.invoke(new CacheSerializableRunnable(title + "client2 add listener") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                region.getAttributesMutator().addCacheListener(new MyListener(false));
                region.registerInterest("ALL_KEYS");
                LogWriterUtils.getLogWriter().info("client2 registerInterest ALL_KEYS at " + region.getFullPath());
            }
        });
        client1.invoke(new CacheSerializableRunnable(title + "do some putAll to get ClientMetaData for future putAll") {

            @Override
            public void run2() throws CacheException {
                doPutAll(regionName, "key-", numberOfEntries);
            }
        });
        WaitCriterion waitForSizes = new WaitCriterion() {

            @Override
            public String description() {
                return "waiting for conditions to be met";
            }

            @Override
            public boolean done() {
                int c1Size = getRegionSize(client1, regionName);
                int c2Size = getRegionSize(client2, regionName);
                int s1Size = getRegionSize(server1, regionName);
                int s2Size = getRegionSize(server2, regionName);
                LogWriterUtils.getLogWriter().info("region sizes: " + c1Size + "," + c2Size + "," + s1Size + "," + s2Size);
                if (c1Size != numberOfEntries) {
                    LogWriterUtils.getLogWriter().info("waiting for client1 to get all updates");
                    return false;
                }
                if (c2Size != numberOfEntries) {
                    LogWriterUtils.getLogWriter().info("waiting for client2 to get all updates");
                    return false;
                }
                if (s1Size != numberOfEntries) {
                    LogWriterUtils.getLogWriter().info("waiting for server1 to get all updates");
                    return false;
                }
                if (s2Size != numberOfEntries) {
                    LogWriterUtils.getLogWriter().info("waiting for server2 to get all updates");
                    return false;
                }
                return true;
            }
        };
        Wait.waitForCriterion(waitForSizes, 10000, 1000, true);
        server1.invoke(new CacheSerializableRunnable(title + "server1 add slow listener") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                region.getAttributesMutator().addCacheListener(new MyListener(true));
            }
        });
        // add a listener that will close the cache at the 10th update
        final SharedCounter sc_server2 = new SharedCounter("server2");
        server2.invoke(new CacheSerializableRunnable(title + "server2 add slow listener") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                region.getAttributesMutator().addCacheListener(new MyListener(server2, true, sc_server2, 10));
            }
        });
        AsyncInvocation async1 = client1.invokeAsync(new CacheSerializableRunnable(title + "client1 add listener and putAll") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                region.getAttributesMutator().addCacheListener(new MyListener(false));
                // create keys
                try {
                    doPutAll(regionName, title, numberOfEntries);
                    fail("Expect ServerOperationException caused by PutAllParitialResultException");
                } catch (ServerOperationException soe) {
                    assertTrue(soe.getMessage().contains(LocalizedStrings.Region_PutAll_Applied_PartialKeys_At_Server_0.toLocalizedString(region.getFullPath())));
                }
            }
        });
        // server2 will closeCache after creating 10 keys
        ThreadUtils.join(async1, 30 * 1000);
        if (async1.exceptionOccurred()) {
            Assert.fail("putAll client threw an exception", async1.getException());
        }
        // restart server2
        System.out.println("restarting server 2");
        createBridgeServer(server2, regionName, serverPort2, true, 0, "ds1");
        // Test Case1: Trigger singleHop putAll. Stop server2 in middle.
        // numberOfEntries/2 + X keys will be created at servers. i.e. X keys at server2,
        // numberOfEntries/2 keys at server1.
        // The client should receive a PartialResultException due to PartitionOffline
        // close a server to re-run the test
        closeCache(server2);
        client1.invoke(new CacheSerializableRunnable(title + "client1 does putAll again") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                // create keys
                try {
                    doPutAll(regionName, title + "again:", numberOfEntries);
                    fail("Expect ServerOperationException caused by PutAllParitialResultException");
                } catch (ServerOperationException soe) {
                    assertTrue(soe.getMessage().contains(LocalizedStrings.Region_PutAll_Applied_PartialKeys_At_Server_0.toLocalizedString(region.getFullPath())));
                }
            }
        });
        // Test Case 2: based on case 1, but this time, there should be no X keys
        // created on server2.
        // restart server2
        createBridgeServer(server2, regionName, serverPort2, true, 0, "ds1");
        // add a cacheWriter for server to fail putAll after it created cacheWriterAllowedKeyNum keys
        server1.invoke(new CacheSerializableRunnable(title + "server1 add cachewriter to throw exception after created some keys") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                region.getAttributesMutator().setCacheWriter(new MyWriter(cacheWriterAllowedKeyNum));
            }
        });
        client1.invoke(new CacheSerializableRunnable(title + "client1 does putAll once more") {

            @Override
            public void run2() throws CacheException {
                Region region = getRootRegion().getSubregion(regionName);
                // create keys
                try {
                    doPutAll(regionName, title + "once more:", numberOfEntries);
                    fail("Expect ServerOperationException caused by PutAllParitialResultException");
                } catch (ServerOperationException soe) {
                    assertTrue(soe.getMessage().contains(LocalizedStrings.Region_PutAll_Applied_PartialKeys_At_Server_0.toLocalizedString(region.getFullPath())));
                }
            }
        });
    } finally {
        server1.invoke(removeExceptionTag1(expectedExceptions));
        server2.invoke(removeExceptionTag1(expectedExceptions));
        client1.invoke(removeExceptionTag1(expectedExceptions));
        client2.invoke(removeExceptionTag1(expectedExceptions));
        // Stop server
        stopBridgeServers(getCache());
    }
}

Example 17 with ServerOperationException

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

the class GatewaySenderEventRemoteDispatcher method _dispatchBatch.

private boolean _dispatchBatch(List events, boolean isRetry) {
    Exception ex = null;
    int currentBatchId = this.processor.getBatchId();
    connection = getConnection(true);
    int batchIdForThisConnection = this.processor.getBatchId();
    GatewaySenderStats statistics = this.sender.getStatistics();
    // i.e The connection has been reset. It also resets the batchId.
    if (currentBatchId != batchIdForThisConnection || this.processor.isConnectionReset()) {
        return false;
    }
    try {
        if (this.processor.isConnectionReset()) {
            isRetry = true;
        }
        SenderProxy sp = new SenderProxy(this.sender.getProxy());
        this.connectionLifeCycleLock.readLock().lock();
        try {
            if (connection != null) {
                sp.dispatchBatch_NewWAN(connection, events, currentBatchId, sender.isRemoveFromQueueOnException(), isRetry);
                if (logger.isDebugEnabled()) {
                    logger.debug("{} : Dispatched batch (id={}) of {} events, queue size: {} on connection {}", this.processor.getSender(), currentBatchId, events.size(), this.processor.getQueue().size(), connection);
                }
            } else {
                throw new ConnectionDestroyedException();
            }
        } finally {
            this.connectionLifeCycleLock.readLock().unlock();
        }
        return true;
    } catch (ServerOperationException e) {
        Throwable t = e.getCause();
        if (t instanceof BatchException70) {
            // A BatchException has occurred.
            // Do not process the connection as dead since it is not dead.
            ex = (BatchException70) t;
        } else {
            ex = e;
            // keep using the connection if we had a batch exception. Else, destroy it
            destroyConnection();
        }
        throw new GatewaySenderException(LocalizedStrings.GatewayEventRemoteDispatcher_0_EXCEPTION_DURING_PROCESSING_BATCH_1_ON_CONNECTION_2.toLocalizedString(new Object[] { this, Integer.valueOf(currentBatchId), connection }), ex);
    } catch (GemFireIOException e) {
        Throwable t = e.getCause();
        if (t instanceof MessageTooLargeException) {
            // A MessageTooLargeException has occurred.
            // Do not process the connection as dead since it is not dead.
            ex = (MessageTooLargeException) t;
            // Reduce the batch size by half of the configured batch size or number of events in the
            // current batch (whichever is less)
            int newBatchSize = Math.min(events.size(), this.processor.getBatchSize()) / 2;
            logger.warn(LocalizedMessage.create(LocalizedStrings.GatewaySenderEventRemoteDispatcher_MESSAGE_TOO_LARGE_EXCEPTION, new Object[] { events.size(), newBatchSize }), e);
            this.processor.setBatchSize(newBatchSize);
            statistics.incBatchesResized();
        } else {
            ex = e;
            // keep using the connection if we had a MessageTooLargeException. Else, destroy it
            destroyConnection();
        }
        throw new GatewaySenderException(LocalizedStrings.GatewayEventRemoteDispatcher_0_EXCEPTION_DURING_PROCESSING_BATCH_1_ON_CONNECTION_2.toLocalizedString(new Object[] { this, Integer.valueOf(currentBatchId), connection }), ex);
    } catch (IllegalStateException e) {
        this.processor.setException(new GatewaySenderException(e));
        throw new GatewaySenderException(LocalizedStrings.GatewayEventRemoteDispatcher_0_EXCEPTION_DURING_PROCESSING_BATCH_1_ON_CONNECTION_2.toLocalizedString(new Object[] { this, Integer.valueOf(currentBatchId), connection }), e);
    } catch (Exception e) {
        // An Exception has occurred. Get its cause.
        Throwable t = e.getCause();
        if (t instanceof IOException) {
            // An IOException has occurred.
            ex = (IOException) t;
        } else {
            ex = e;
        }
        // the cause is not going to be BatchException70. So, destroy the connection
        destroyConnection();
        throw new GatewaySenderException(LocalizedStrings.GatewayEventRemoteDispatcher_0_EXCEPTION_DURING_PROCESSING_BATCH_1_ON_CONNECTION_2.toLocalizedString(new Object[] { this, Integer.valueOf(currentBatchId), connection }), ex);
    }
}

Example 18 with ServerOperationException

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

the class ExecuteFunctionOp method execute.

/**
   * Does a execute Function on a server using connections from the given pool to communicate with
   * the server.
   * 
   * @param pool the pool to use to communicate with the server.
   * @param function of the function to be executed
   * @param args specified arguments to the application function
   */
public static void execute(final PoolImpl pool, Function function, ServerFunctionExecutor executor, Object args, MemberMappedArgument memberMappedArg, boolean allServers, byte hasResult, ResultCollector rc, boolean isFnSerializationReqd, UserAttributes attributes, String[] groups) {
    final AbstractOp op = new ExecuteFunctionOpImpl(function, args, memberMappedArg, hasResult, rc, isFnSerializationReqd, (byte) 0, groups, allServers, executor.isIgnoreDepartedMembers());
    if (allServers && groups.length == 0) {
        if (logger.isDebugEnabled()) {
            logger.debug("ExecuteFunctionOp#execute : Sending Function Execution Message:{} to all servers using pool: {}", op.getMessage(), pool);
        }
        List callableTasks = constructAndGetFunctionTasks(pool, function, args, memberMappedArg, hasResult, rc, isFnSerializationReqd, attributes);
        SingleHopClientExecutor.submitAll(callableTasks);
    } else {
        boolean reexecuteForServ = false;
        AbstractOp reexecOp = null;
        int retryAttempts = 0;
        boolean reexecute = false;
        int maxRetryAttempts = 0;
        if (function.isHA())
            maxRetryAttempts = pool.getRetryAttempts();
        final boolean isDebugEnabled = logger.isDebugEnabled();
        do {
            try {
                if (reexecuteForServ) {
                    if (isDebugEnabled) {
                        logger.debug("ExecuteFunctionOp#execute.reexecuteForServ : Sending Function Execution Message:{} to server using pool: {} with groups:{} all members:{} ignoreFailedMembers:{}", op.getMessage(), pool, Arrays.toString(groups), allServers, executor.isIgnoreDepartedMembers());
                    }
                    reexecOp = new ExecuteFunctionOpImpl(function, args, memberMappedArg, hasResult, rc, isFnSerializationReqd, (byte) 1, /* isReExecute */
                    groups, allServers, executor.isIgnoreDepartedMembers());
                    pool.execute(reexecOp, 0);
                } else {
                    if (isDebugEnabled) {
                        logger.debug("ExecuteFunctionOp#execute : Sending Function Execution Message:{} to server using pool: {} with groups:{} all members:{} ignoreFailedMembers:{}", op.getMessage(), pool, Arrays.toString(groups), allServers, executor.isIgnoreDepartedMembers());
                    }
                    pool.execute(op, 0);
                }
                reexecute = false;
                reexecuteForServ = false;
            } catch (InternalFunctionInvocationTargetException e) {
                if (isDebugEnabled) {
                    logger.debug("ExecuteFunctionOp#execute : Received InternalFunctionInvocationTargetException. The failed node is {}", e.getFailedNodeSet());
                }
                reexecute = true;
                rc.clearResults();
            } catch (ServerConnectivityException se) {
                retryAttempts++;
                if (isDebugEnabled) {
                    logger.debug("ExecuteFunctionOp#execute : Received ServerConnectivityException. The exception is {} The retryAttempt is : {} maxRetryAttempts  {}", se, retryAttempts, maxRetryAttempts);
                }
                if (se instanceof ServerOperationException) {
                    throw se;
                }
                if ((retryAttempts > maxRetryAttempts && maxRetryAttempts != -1))
                    throw se;
                reexecuteForServ = true;
                rc.clearResults();
            }
        } while (reexecuteForServ);
        if (reexecute && function.isHA()) {
            ExecuteFunctionOp.reexecute(pool, function, executor, rc, hasResult, isFnSerializationReqd, maxRetryAttempts - 1, groups, allServers);
        }
    }
}

Example 19 with ServerOperationException

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

the class PutOp method execute.

/**
   * Does a region put on a server using connections from the given pool to communicate with the
   * server.
   * 
   * @param pool the pool to use to communicate with the server.
   * @param region the region to do the put on
   * @param key the entry key to do the put on
   * @param value the entry value to put
   * @param event the event for this put
   * @param requireOldValue
   * @param expectedOldValue
   * @param callbackArg an optional callback arg to pass to any cache callbacks
   */
public static Object execute(ExecutablePool pool, LocalRegion region, Object key, Object value, byte[] deltaBytes, EntryEventImpl event, Operation operation, boolean requireOldValue, Object expectedOldValue, Object callbackArg, boolean prSingleHopEnabled) {
    PutOpImpl op = new PutOpImpl(region, key, value, deltaBytes, event, operation, requireOldValue, expectedOldValue, callbackArg, false, /* donot send full obj; send delta */
    prSingleHopEnabled);
    if (prSingleHopEnabled) {
        ClientMetadataService cms = region.getCache().getClientMetadataService();
        ServerLocation server = cms.getBucketServerLocation(region, Operation.UPDATE, key, value, callbackArg);
        if (server != null) {
            try {
                PoolImpl poolImpl = (PoolImpl) pool;
                boolean onlyUseExistingCnx = ((poolImpl.getMaxConnections() != -1 && poolImpl.getConnectionCount() >= poolImpl.getMaxConnections()) ? true : false);
                op.setAllowDuplicateMetadataRefresh(!onlyUseExistingCnx);
                return pool.executeOn(new ServerLocation(server.getHostName(), server.getPort()), op, true, onlyUseExistingCnx);
            } catch (AllConnectionsInUseException e) {
            } catch (ServerConnectivityException e) {
                if (e instanceof ServerOperationException) {
                    // fixed 44656
                    throw e;
                }
                cms.removeBucketServerLocation(server);
            }
        }
    }
    return pool.execute(op);
}

Example 20 with ServerOperationException

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

the class ResourceManagerWithQueryMonitorDUnitTest method doCriticalMemoryHitDuringGatherTestWithMultipleServers.

// tests low memory hit while gathering partition region results
private void doCriticalMemoryHitDuringGatherTestWithMultipleServers(final String regionName, boolean createPR, final int criticalThreshold, final boolean disabledQueryMonitorForLowMem, final int queryTimeout, final boolean hitCriticalThreshold) throws Exception {
    // create region on the server
    final Host host = Host.getHost(0);
    final VM server1 = host.getVM(0);
    final VM server2 = host.getVM(1);
    final VM client = host.getVM(2);
    final int numObjects = 200;
    try {
        final int[] port = AvailablePortHelper.getRandomAvailableTCPPorts(2);
        startCacheServer(server1, port[0], criticalThreshold, disabledQueryMonitorForLowMem, queryTimeout, regionName, createPR, 0);
        startCacheServer(server2, port[1], criticalThreshold, true, -1, regionName, createPR, 0);
        startClient(client, server1, port[0], regionName);
        populateData(server2, regionName, numObjects);
        createCancelDuringGatherTestHook(server1);
        client.invoke(new SerializableCallable("executing query to be canceled by gather") {

            public Object call() {
                QueryService qs = null;
                try {
                    qs = getCache().getQueryService();
                    Query query = qs.newQuery("Select * From /" + regionName);
                    query.execute();
                } catch (ServerOperationException soe) {
                    if (soe.getRootCause() instanceof QueryException) {
                        QueryException e = (QueryException) soe.getRootCause();
                        if (!isExceptionDueToLowMemory(e, CRITICAL_HEAP_USED)) {
                            throw new CacheException(soe) {
                            };
                        } else {
                            return 0;
                        }
                    }
                } catch (Exception e) {
                    throw new CacheException(e) {
                    };
                }
                // assertTrue(((CancelDuringGatherHook)DefaultQuery.testHook).triggeredOOME);
                throw new CacheException("should have hit low memory") {
                };
            }
        });
        verifyRejectedObjects(server1, disabledQueryMonitorForLowMem, queryTimeout, hitCriticalThreshold);
        // Pause for a second and then let's recover
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // Recover from critical heap
        if (hitCriticalThreshold) {
            vmRecoversFromCriticalHeap(server1);
        }
        // Check to see if query execution is ok under "normal" or "healthy" conditions
        client.invoke(new CacheSerializableRunnable("Executing query when system is 'Normal'") {

            public void run2() {
                try {
                    QueryService qs = getCache().getQueryService();
                    Query query = qs.newQuery("Select * From /" + regionName);
                    SelectResults results = (SelectResults) query.execute();
                    assertEquals(numObjects, results.size());
                } catch (QueryInvocationTargetException e) {
                    assertFalse(true);
                } catch (NameResolutionException e) {
                    assertFalse(true);
                } catch (TypeMismatchException e) {
                    assertFalse(true);
                } catch (FunctionDomainException e) {
                    assertFalse(true);
                }
            }
        });
        // Recover from critical heap
        if (hitCriticalThreshold) {
            vmRecoversFromCriticalHeap(server1);
        }
    } finally {
        stopServer(server1);
        stopServer(server2);
    }
}