class UserFunctionExecution implements InternalFunction<Object[]> {

  @Override
  public void execute(FunctionContext<Object[]> context) {
    Cache cache = ((InternalCache) context.getCache()).getCacheForProcessingClientRequests();
    DistributedMember member = cache.getDistributedSystem().getDistributedMember();

    Object[] args = context.getArguments();
    if (args == null) {
      context.getResultSender().lastResult(new CliFunctionResult(context.getMemberName(), ERROR,
          CliStrings.EXECUTE_FUNCTION__MSG__COULD_NOT_RETRIEVE_ARGUMENTS));
      return;
    }

    String functionId = ((String) args[0]);
    String filterString = ((String) args[1]);
    String resultCollectorName = ((String) args[2]);
    String argumentsString = ((String) args[3]);
    String onRegion = ((String) args[4]);
    Properties credentials = (Properties) args[5];
    SecurityService securityService = ((InternalCache) context.getCache()).getSecurityService();

    boolean loginSuccessful = false;
    try {

      // Authenticate If Needed
      if (loginRequired(securityService)) {
        securityService.login(credentials);
        loginSuccessful = true;
      }

      // Load User Function
      Function<?> function = loadFunction(functionId);
      if (function == null) {
        context.getResultSender()
            .lastResult(new CliFunctionResult(context.getMemberName(), ERROR,
                (CliStrings.format(
                    CliStrings.EXECUTE_FUNCTION__MSG__DOES_NOT_HAVE_FUNCTION_0_REGISTERED,
                    functionId))));
        return;
      }

      // Parse Arguments
      Set<String> filters = parseFilters(filterString);
      String[] functionArgs = parseArguments(argumentsString);
      ResultCollector<Object, List<Object>> resultCollectorInstance =
          parseResultCollector(resultCollectorName);

      // Security check
      function.getRequiredPermissions(onRegion, functionArgs).forEach(securityService::authorize);

      // Build & Configure Execution Context
      Execution<Object, Object, List<Object>> execution = buildExecution(cache, onRegion);
      if (execution == null) {
        context.getResultSender()
            .lastResult(new CliFunctionResult(context.getMemberName(), ERROR,
                CliStrings.format(
                    CliStrings.EXECUTE_FUNCTION__MSG__ERROR_IN_EXECUTING_0_ON_MEMBER_1_ON_REGION_2_DETAILS_3,
                    functionId, member.getId(), onRegion,
                    CliStrings.EXECUTE_FUNCTION__MSG__ERROR_IN_RETRIEVING_EXECUTOR)));
        return;
      }

      if (resultCollectorInstance != null) {
        execution = execution.withCollector(resultCollectorInstance);
      }

      if (functionArgs != null && functionArgs.length > 0) {
        execution = execution.setArguments(functionArgs);
      }

      if (filters.size() > 0) {
        execution = execution.withFilter(filters);
      }

      // Execute Function and gather results
      List<Object> results = null;
      boolean functionSuccess = true;
      List<String> resultMessage = new ArrayList<>();

      ResultCollector<Object, List<Object>> rc = execution.execute(function.getId());
      if (function.hasResult()) {
        results = rc.getResult();
      }

      if (results != null) {
        for (Object resultObj : results) {
          if (resultObj != null) {
            if (resultObj instanceof Exception) {
              resultMessage.add(((Exception) resultObj).getMessage());
              functionSuccess = false;
            } else {
              resultMessage.add(resultObj.toString());
            }
          }
        }
      }

      context.getResultSender().lastResult(new CliFunctionResult(context.getMemberName(),
          functionSuccess ? OK : ERROR, resultMessage.toString()));
    } catch (RegionNotFoundException regionNotFoundException) {
      context.getResultSender().lastResult(
          new CliFunctionResult(context.getMemberName(), ERROR, onRegion + " does not exist"));
    } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
      context.getResultSender()
          .lastResult(new CliFunctionResult(context.getMemberName(), ERROR,
              CliStrings.format(
                  CliStrings.EXECUTE_FUNCTION__MSG__RESULT_COLLECTOR_0_NOT_FOUND_ERROR_1,
                  resultCollectorName, e.getMessage())));
    } catch (Exception e) {
      logger.error("error executing function " + functionId, e);
      context.getResultSender().lastResult(
          new CliFunctionResult(context.getMemberName(), ERROR, "Exception: " + e.getMessage()));
    } finally {
      if (loginSuccessful) {
        securityService.logout();
      }
    }
  }

}