Examples with FunctionStats org.apache.geode.internal.cache.execute.FunctionStats used on opensource projects

Example 1 with FunctionStats

use of org.apache.geode.internal.cache.execute.FunctionStats in project geode by apache.

the class ExecuteFunction65 method cmdExecute.

@Override
public void cmdExecute(Message clientMessage, ServerConnection servConn, long start) throws IOException {
    Object function = null;
    Object args = null;
    MemberMappedArgument memberMappedArg = null;
    byte hasResult = 0;
    byte functionState = 0;
    boolean isReexecute = false;
    try {
        functionState = clientMessage.getPart(0).getSerializedForm()[0];
        if (functionState == AbstractExecution.HA_HASRESULT_NO_OPTIMIZEFORWRITE_REEXECUTE) {
            functionState = AbstractExecution.HA_HASRESULT_NO_OPTIMIZEFORWRITE;
            isReexecute = true;
        } else if (functionState == AbstractExecution.HA_HASRESULT_OPTIMIZEFORWRITE_REEXECUTE) {
            functionState = AbstractExecution.HA_HASRESULT_OPTIMIZEFORWRITE;
            isReexecute = true;
        }
        if (functionState != 1) {
            hasResult = (byte) ((functionState & 2) - 1);
        } else {
            hasResult = functionState;
        }
        if (hasResult == 1) {
            servConn.setAsTrue(REQUIRES_RESPONSE);
            servConn.setAsTrue(REQUIRES_CHUNKED_RESPONSE);
        }
        function = clientMessage.getPart(1).getStringOrObject();
        args = clientMessage.getPart(2).getObject();
        Part part = clientMessage.getPart(3);
        if (part != null) {
            memberMappedArg = (MemberMappedArgument) part.getObject();
        }
    } catch (ClassNotFoundException exception) {
        logger.warn(LocalizedMessage.create(LocalizedStrings.ExecuteFunction_EXCEPTION_ON_SERVER_WHILE_EXECUTIONG_FUNCTION_0, function), exception);
        if (hasResult == 1) {
            writeChunkedException(clientMessage, exception, servConn);
            servConn.setAsTrue(RESPONDED);
            return;
        }
    }
    if (function == null) {
        final String message = LocalizedStrings.ExecuteFunction_THE_INPUT_FUNCTION_FOR_THE_EXECUTE_FUNCTION_REQUEST_IS_NULL.toLocalizedString();
        logger.warn("{}: {}", servConn.getName(), message);
        sendError(hasResult, clientMessage, message, servConn);
        return;
    }
    // Execute function on the cache
    try {
        Function functionObject = null;
        if (function instanceof String) {
            functionObject = FunctionService.getFunction((String) function);
            if (functionObject == null) {
                final String message = LocalizedStrings.ExecuteFunction_FUNCTION_NAMED_0_IS_NOT_REGISTERED.toLocalizedString(function);
                logger.warn("{}: {}", servConn.getName(), message);
                sendError(hasResult, clientMessage, message, servConn);
                return;
            } else {
                byte functionStateOnServerSide = AbstractExecution.getFunctionState(functionObject.isHA(), functionObject.hasResult(), functionObject.optimizeForWrite());
                if (logger.isDebugEnabled()) {
                    logger.debug("Function State on server side: {} on client: {}", functionStateOnServerSide, functionState);
                }
                if (functionStateOnServerSide != functionState) {
                    String message = LocalizedStrings.FunctionService_FUNCTION_ATTRIBUTE_MISMATCH_CLIENT_SERVER.toLocalizedString(function);
                    logger.warn("{}: {}", servConn.getName(), message);
                    sendError(hasResult, clientMessage, message, servConn);
                    return;
                }
            }
        } else {
            functionObject = (Function) function;
        }
        FunctionStats stats = FunctionStats.getFunctionStats(functionObject.getId());
        this.securityService.authorizeDataWrite();
        // check if the caller is authorized to do this operation on server
        AuthorizeRequest authzRequest = servConn.getAuthzRequest();
        ExecuteFunctionOperationContext executeContext = null;
        if (authzRequest != null) {
            executeContext = authzRequest.executeFunctionAuthorize(functionObject.getId(), null, null, args, functionObject.optimizeForWrite());
        }
        ChunkedMessage m = servConn.getFunctionResponseMessage();
        m.setTransactionId(clientMessage.getTransactionId());
        ResultSender resultSender = new ServerToClientFunctionResultSender65(m, MessageType.EXECUTE_FUNCTION_RESULT, servConn, functionObject, executeContext);
        InternalDistributedMember localVM = (InternalDistributedMember) servConn.getCache().getDistributedSystem().getDistributedMember();
        FunctionContext context = null;
        if (memberMappedArg != null) {
            context = new FunctionContextImpl(functionObject.getId(), memberMappedArg.getArgumentsForMember(localVM.getId()), resultSender, isReexecute);
        } else {
            context = new FunctionContextImpl(functionObject.getId(), args, resultSender, isReexecute);
        }
        HandShake handShake = (HandShake) servConn.getHandshake();
        int earlierClientReadTimeout = handShake.getClientReadTimeout();
        handShake.setClientReadTimeout(0);
        try {
            long startExecution = stats.startTime();
            stats.startFunctionExecution(functionObject.hasResult());
            if (logger.isDebugEnabled()) {
                logger.debug("Executing Function on Server: {} with context: {}", servConn, context);
            }
            InternalCache cache = servConn.getCache();
            HeapMemoryMonitor hmm = ((InternalResourceManager) cache.getResourceManager()).getHeapMonitor();
            if (functionObject.optimizeForWrite() && cache != null && hmm.getState().isCritical() && !MemoryThresholds.isLowMemoryExceptionDisabled()) {
                Set<DistributedMember> sm = Collections.singleton((DistributedMember) cache.getMyId());
                Exception e = new LowMemoryException(LocalizedStrings.ResourceManager_LOW_MEMORY_FOR_0_FUNCEXEC_MEMBERS_1.toLocalizedString(new Object[] { functionObject.getId(), sm }), sm);
                sendException(hasResult, clientMessage, e.getMessage(), servConn, e);
                return;
            }
            functionObject.execute(context);
            if (!((ServerToClientFunctionResultSender65) resultSender).isLastResultReceived() && functionObject.hasResult()) {
                throw new FunctionException(LocalizedStrings.ExecuteFunction_THE_FUNCTION_0_DID_NOT_SENT_LAST_RESULT.toString(functionObject.getId()));
            }
            stats.endFunctionExecution(startExecution, functionObject.hasResult());
        } catch (FunctionException functionException) {
            stats.endFunctionExecutionWithException(functionObject.hasResult());
            throw functionException;
        } catch (Exception exception) {
            stats.endFunctionExecutionWithException(functionObject.hasResult());
            throw new FunctionException(exception);
        } finally {
            handShake.setClientReadTimeout(earlierClientReadTimeout);
        }
    } catch (IOException ioException) {
        logger.warn(LocalizedMessage.create(LocalizedStrings.ExecuteFunction_EXCEPTION_ON_SERVER_WHILE_EXECUTIONG_FUNCTION_0, function), ioException);
        String message = LocalizedStrings.ExecuteFunction_SERVER_COULD_NOT_SEND_THE_REPLY.toLocalizedString();
        sendException(hasResult, clientMessage, message, servConn, ioException);
    } catch (InternalFunctionInvocationTargetException internalfunctionException) {
        // 2> in case of HA member departed
        if (logger.isDebugEnabled()) {
            logger.debug(LocalizedMessage.create(LocalizedStrings.ExecuteFunction_EXCEPTION_ON_SERVER_WHILE_EXECUTIONG_FUNCTION_0, new Object[] { function }), internalfunctionException);
        }
        final String message = internalfunctionException.getMessage();
        sendException(hasResult, clientMessage, message, servConn, internalfunctionException);
    } catch (Exception e) {
        logger.warn(LocalizedMessage.create(LocalizedStrings.ExecuteFunction_EXCEPTION_ON_SERVER_WHILE_EXECUTIONG_FUNCTION_0, function), e);
        final String message = e.getMessage();
        sendException(hasResult, clientMessage, message, servConn, e);
    }
}

Example 2 with FunctionStats

use of org.apache.geode.internal.cache.execute.FunctionStats in project geode by apache.

the class MemberFunctionStreamingMessage method process.

@Override
protected void process(final DistributionManager dm) {
    Throwable thr = null;
    ReplyException rex = null;
    if (this.functionObject == null) {
        rex = new ReplyException(new FunctionException(LocalizedStrings.ExecuteFunction_FUNCTION_NAMED_0_IS_NOT_REGISTERED.toLocalizedString(this.functionName)));
        replyWithException(dm, rex);
        return;
    }
    FunctionStats stats = FunctionStats.getFunctionStats(this.functionObject.getId(), dm.getSystem());
    TXStateProxy tx = null;
    try {
        tx = prepForTransaction();
        ResultSender resultSender = new MemberFunctionResultSender(dm, this, this.functionObject);
        Set<Region> regions = new HashSet<Region>();
        if (this.regionPathSet != null) {
            InternalCache cache = GemFireCacheImpl.getInstance();
            for (String regionPath : this.regionPathSet) {
                if (checkCacheClosing(dm) || checkDSClosing(dm)) {
                    thr = new CacheClosedException(LocalizedStrings.PartitionMessage_REMOTE_CACHE_IS_CLOSED_0.toLocalizedString(dm.getId()));
                    return;
                }
                regions.add(cache.getRegion(regionPath));
            }
        }
        FunctionContextImpl context = new MultiRegionFunctionContextImpl(this.functionObject.getId(), this.args, resultSender, regions, isReExecute);
        long start = stats.startTime();
        stats.startFunctionExecution(this.functionObject.hasResult());
        if (logger.isDebugEnabled()) {
            logger.debug("Executing Function: {} on remote member with context: {}", this.functionObject.getId(), context.toString());
        }
        this.functionObject.execute(context);
        if (!this.replyLastMsg && this.functionObject.hasResult()) {
            throw new FunctionException(LocalizedStrings.ExecuteFunction_THE_FUNCTION_0_DID_NOT_SENT_LAST_RESULT.toString(functionObject.getId()));
        }
        stats.endFunctionExecution(start, this.functionObject.hasResult());
    } catch (FunctionException functionException) {
        if (logger.isDebugEnabled()) {
            logger.debug("FunctionException occurred on remote member while executing Function: {}", this.functionObject.getId(), functionException);
        }
        stats.endFunctionExecutionWithException(this.functionObject.hasResult());
        rex = new ReplyException(functionException);
        replyWithException(dm, rex);
    // thr = functionException.getCause();
    } catch (CancelException exception) {
        // bug 37026: this is too noisy...
        // throw new CacheClosedException("remote system shutting down");
        // thr = se; cache is closed, no point trying to send a reply
        thr = new FunctionInvocationTargetException(exception);
        stats.endFunctionExecutionWithException(this.functionObject.hasResult());
        rex = new ReplyException(thr);
        replyWithException(dm, rex);
    } catch (Exception exception) {
        if (logger.isDebugEnabled()) {
            logger.debug("Exception occurred on remote member while executing Function: {}", this.functionObject.getId(), exception);
        }
        stats.endFunctionExecutionWithException(this.functionObject.hasResult());
        rex = new ReplyException(exception);
        replyWithException(dm, rex);
    // thr = e.getCause();
    } catch (VirtualMachineError err) {
        SystemFailure.initiateFailure(err);
        // now, so don't let this thread continue.
        throw err;
    } catch (Throwable t) {
        // Whenever you catch Error or Throwable, you must also
        // catch VirtualMachineError (see above). However, there is
        // _still_ a possibility that you are dealing with a cascading
        // error condition, so you also need to check to see if the JVM
        // is still usable:
        SystemFailure.checkFailure();
        thr = t;
    } finally {
        cleanupTransaction(tx);
        if (thr != null) {
            rex = new ReplyException(thr);
            replyWithException(dm, rex);
        }
    }
}

Example 3 with FunctionStats

use of org.apache.geode.internal.cache.execute.FunctionStats in project geode by apache.

the class InternalDistributedSystem method disconnect.

/**
   * Disconnects this VM from the distributed system. Shuts down the distribution manager.
   * 
   * @param preparingForReconnect true if called by a reconnect operation
   * @param reason the reason the disconnect is being performed
   * @param keepAlive true if user requested durable subscriptions are to be retained at server.
   */
protected void disconnect(boolean preparingForReconnect, String reason, boolean keepAlive) {
    boolean isShutdownHook = (shutdownHook != null) && (Thread.currentThread() == shutdownHook);
    if (!preparingForReconnect) {
        // logger.info("disconnecting IDS@"+System.identityHashCode(this));
        synchronized (reconnectListeners) {
            reconnectListeners.clear();
        }
        cancelReconnect();
    }
    final boolean isDebugEnabled = logger.isDebugEnabled();
    try {
        HashSet shutdownListeners = null;
        try {
            if (isDebugEnabled) {
                logger.debug("DistributedSystem.disconnect invoked on {}", this);
            }
            synchronized (GemFireCacheImpl.class) {
                // bug 36955, 37014: don't use a disconnect listener on the cache;
                // it takes too long.
                //
                // However, make sure cache is completely closed before starting
                // the distributed system close.
                InternalCache currentCache = GemFireCacheImpl.getInstance();
                if (currentCache != null && !currentCache.isClosed()) {
                    // bug #42663 - this must be set while
                    disconnectListenerThread.set(Boolean.TRUE);
                    // closing the cache
                    try {
                        // fix for 42150
                        currentCache.close(reason, dm.getRootCause(), keepAlive, true);
                    } catch (VirtualMachineError e) {
                        SystemFailure.initiateFailure(e);
                        throw e;
                    } catch (Throwable e) {
                        SystemFailure.checkFailure();
                        // Whenever you catch Error or Throwable, you must also
                        // check for fatal JVM error (see above). However, there is
                        logger.warn(LocalizedMessage.create(LocalizedStrings.InternalDistributedSystem_EXCEPTION_TRYING_TO_CLOSE_CACHE), e);
                    } finally {
                        disconnectListenerThread.set(Boolean.FALSE);
                    }
                }
                // marked as shutting down
                synchronized (this) {
                    if (this.isDisconnecting) {
                        // It's already started, but don't return
                        // to the caller until it has completed.
                        waitDisconnected();
                        return;
                    }
                    // isDisconnecting
                    this.isDisconnecting = true;
                    if (!preparingForReconnect) {
                        // move cancelReconnect above this synchronized block fix for bug 35202
                        if (this.reconnectDS != null) {
                            // break recursion
                            if (isDebugEnabled) {
                                logger.debug("disconnecting reconnected DS: {}", this.reconnectDS);
                            }
                            InternalDistributedSystem r = this.reconnectDS;
                            this.reconnectDS = null;
                            r.disconnect(false, null, false);
                        }
                    }
                // !reconnect
                }
            // synchronized (this)
            }
            if (!isShutdownHook) {
                shutdownListeners = doDisconnects(attemptingToReconnect, reason);
            }
            if (!this.attemptingToReconnect) {
                if (this.logWriterAppender != null) {
                    LogWriterAppenders.stop(LogWriterAppenders.Identifier.MAIN);
                }
                if (this.securityLogWriterAppender != null) {
                    // LOG:SECURITY: old code did NOT invoke this
                    LogWriterAppenders.stop(LogWriterAppenders.Identifier.SECURITY);
                }
            }
            AlertAppender.getInstance().shuttingDown();
        } finally {
            // be ABSOLUTELY CERTAIN that dm closed
            try {
                // Do the bulk of the close...
                this.dm.close();
                // is enabled, loss of the locator doesn't cause the DM to croak
                if (this.startedLocator != null) {
                    this.startedLocator.stop(forcedDisconnect, preparingForReconnect, false);
                    this.startedLocator = null;
                }
            } finally {
                // the DM is closed :-(
                if (!preparingForReconnect) {
                    SystemTimer.cancelSwarm(this);
                }
            }
        // finally timer cancelled
        }
        if (!isShutdownHook) {
            doShutdownListeners(shutdownListeners);
        }
        // closing the Aggregate stats
        if (functionServiceStats != null) {
            functionServiceStats.close();
        }
        // closing individual function stats
        for (FunctionStats functionstats : functionExecutionStatsMap.values()) {
            functionstats.close();
        }
        (new FunctionServiceManager()).unregisterAllFunctions();
        if (this.sampler != null) {
            this.sampler.stop();
            this.sampler = null;
        }
        if (!this.attemptingToReconnect) {
            if (this.logWriterAppender != null) {
                LogWriterAppenders.destroy(LogWriterAppenders.Identifier.MAIN);
            }
            if (this.securityLogWriterAppender != null) {
                LogWriterAppenders.destroy(LogWriterAppenders.Identifier.SECURITY);
            }
        }
        // NOTE: no logging after this point :-)
        // bug35388 - logwriters accumulate, causing mem
        LoggingThreadGroup.cleanUpThreadGroups();
        // leak
        EventID.unsetDS();
    } finally {
        try {
            if (getOffHeapStore() != null) {
                getOffHeapStore().close();
            }
        } finally {
            try {
                removeSystem(this);
                // Close the config object
                this.config.close();
            } finally {
                // Finally, mark ourselves as disconnected
                setDisconnected();
                SystemFailure.stopThreads();
            }
        }
    }
}

Example 4 with FunctionStats

use of org.apache.geode.internal.cache.execute.FunctionStats in project geode by apache.

the class InternalDistributedSystem method getFunctionStats.

public FunctionStats getFunctionStats(String textId) {
    FunctionStats stats = (FunctionStats) functionExecutionStatsMap.get(textId);
    if (stats == null) {
        stats = new FunctionStats(this, textId);
        FunctionStats oldStats = functionExecutionStatsMap.putIfAbsent(textId, stats);
        if (oldStats != null) {
            stats.close();
            stats = oldStats;
        }
    }
    return stats;
}

Example 5 with FunctionStats

use of org.apache.geode.internal.cache.execute.FunctionStats in project geode by apache.

the class PartitionedRegionDataStore method executeOnDataStore.

public void executeOnDataStore(final Set localKeys, final Function function, final Object object, final int prid, final Set<Integer> bucketSet, final boolean isReExecute, final PartitionedRegionFunctionStreamingMessage msg, long time, ServerConnection servConn, int transactionID) {
    if (!areAllBucketsHosted(bucketSet)) {
        throw new BucketMovedException(LocalizedStrings.FunctionService_BUCKET_MIGRATED_TO_ANOTHER_NODE.toLocalizedString());
    }
    final DM dm = this.partitionedRegion.getDistributionManager();
    ResultSender resultSender = new PartitionedRegionFunctionResultSender(dm, this.partitionedRegion, time, msg, function, bucketSet);
    final RegionFunctionContextImpl prContext = new RegionFunctionContextImpl(function.getId(), this.partitionedRegion, object, localKeys, ColocationHelper.constructAndGetAllColocatedLocalDataSet(this.partitionedRegion, bucketSet), bucketSet, resultSender, isReExecute);
    FunctionStats stats = FunctionStats.getFunctionStats(function.getId(), dm.getSystem());
    try {
        long start = stats.startTime();
        stats.startFunctionExecution(function.hasResult());
        if (logger.isDebugEnabled()) {
            logger.debug("Executing Function: {} on Remote Node with context: ", function.getId(), prContext);
        }
        function.execute(prContext);
        stats.endFunctionExecution(start, function.hasResult());
    } catch (FunctionException functionException) {
        if (logger.isDebugEnabled()) {
            logger.debug("FunctionException occurred on remote node while executing Function: {}", function.getId(), functionException);
        }
        stats.endFunctionExecutionWithException(function.hasResult());
        if (functionException.getCause() instanceof QueryInvalidException) {
            // create a new FunctionException on the original one's message (not cause).
            throw new FunctionException(functionException.getLocalizedMessage());
        }
        throw functionException;
    }
}