return the executor used to execute the permit
965357
def executor(user_account, options = {}) 
      @executor ||= case self.class.name
      when /System/
        then Permit::Executor::System.new self, user_account, options
      else  
        Permit::Executor::Base.new self, user_account, options
      end
    end
749320
public QueueBuilder<T>  executor(Executor executor)
    {
        Preconditions.checkNotNull(executor, "executor cannot be null");

        this.executor = executor;
        return this;
    }
1233713
public CallOptions withExecutor(@Nullable Executor executor) {
    CallOptions newOptions = new CallOptions(this);
    newOptions.executor = executor;
    return newOptions;
  }
721134
def delegate(self, fn, *args, **kwargs):
        """"""
        return self.subexecutor.spawn(fn, *args, **kwargs)
667364
def _jinja_executor_template(self):
        """"""
        template = self.campaign.process.executor_template
        if template.startswith('#!'):
            return jinja_environment.from_string(template)
        else:
            return jinja_environment.get_template(template)
630396
protected QueryExecutor<S> executor() throws RepositoryException {
        QueryExecutor<S> executor = mExecutor;
        if (executor == null) {
            mExecutor = executor = executorFactory().executor(mFilter, mOrdering, null);
        }
        return executor;
    }
651102
def get_execution(self, id_execution, access_token=None, user_id=None):
        
        if access_token:
            self.req.credential.set_token(access_token)
        if user_id:
            self.req.credential.set_user_id(user_id)
        if not self.check_credentials():
            raise CredentialsError('credentials invalid')
        execution = self.req.get('/Executions/' + id_execution)
        if "codeId" in execution:
            execution['code'] = self.get_code(execution["codeId"])
        return execution
211697
def _executor(self):
        '''
            
        '''
        if self.EXECUTE_PARALLEL is False:
            executor_path = "batch_requests.concurrent.executor.SequentialExecutor"
            executor_class = import_class(executor_path)
            return executor_class()
        else:
            executor_path = self.CONCURRENT_EXECUTOR
            executor_class = import_class(executor_path)
            return executor_class(self.NUM_WORKERS)
86321
def execute(self):
        
        if hasattr(self, "_executed"):
            return self._executed

        es = connections.get_connection(self._using)

        if getattr(self, "_full", False) is False:
            self._executed = ShallowResponse(es.search(index=self._index,
                                                   doc_type=self._doc_type,
                                                   body=self.to_dict(),
                                                   **self._params),
                                         callbacks=self._doc_type_map)
        else:
            self._executed = FullResponse(es.search(index=self._index,
                                                doc_type=self._doc_type,
                                                body=self.to_dict(),
                                                **self._params))

        return self._executed
1323374
def _acquire_lock_and_execute(lock_manager: ConsulLockManager, configuration: CliLockAndExecuteConfiguration):
    
    lock = _acquire_lock(lock_manager, configuration)
    if lock is None:
        exit(UNABLE_TO_ACQUIRE_LOCK_EXIT_CODE)
    return_code, _, _ = lock_manager.execute_with_lock(configuration.executable, lock)
    exit(return_code)
1199974
def execute_action_command(command: nil)
      command_return = @command_executor.execute(command: command, target_object: nil)
      ## probably need to just return Strings, or ready_for_next with object isn't String
      return_object = command_return.return_value
      return_value_type = command_return.return_value_type
      closure_arg = command_return.closure_argument_value

      return_object = return_value_processor.prepare_object(
        return_value: return_object,
        return_value_type: return_value_type
      )

      if closure_arg.nil?
        closure_arg = closure_arg.to_s
      else
        closure_arg = return_value_processor.prepare_object(
          return_value: closure_arg,
          return_value_type: :string # always assume string for closure error_callback
        )
      end

      Thread.current[:exception] = nil

      payload = {
        payload: {
          status: "ready_for_next",
          return_object: return_object,
          closure_argument_value: closure_arg
        }
      }
      return JSON.generate(payload)
    rescue StandardError => e
      Thread.current[:exception] = e

      exception_array = []
      exception_array << "#{e.class}:"
      exception_array << e.backtrace

      while e.respond_to?("cause") && (e = e.cause)
        exception_array << "cause: #{e.class}"
        exception_array << e.backtrace
      end

      payload = {
        payload: {
          status: "failure",
          failure_information: exception_array.flatten
        }
      }
      return JSON.generate(payload)
    end
1106138
def runOnExecutor(self, *commands, oper=ACCEPT, defer_shell_expansion=False):
        
        return self.makeOutput(EXE, commands, oper=oper, defer_shell_expansion=defer_shell_expansion)
378274
def autoexec(pipe=None, name=None, exit_handler=None):
    
    return pipeline(pipe=pipe, name=name, autoexec=True,
                    exit_handler=exit_handler)
674576
def command_executor(self):
        """"""
        ip_address = self.ip_address if self.ip_address else '127.0.0.1'
        return 'http://{}:{}/wd/hub'.format(ip_address, self.port)
1179640
function createExecutor(serverUrl) {
  let client = serverUrl.then(url => new http.HttpClient(url));
  let executor = new http.Executor(client);
  configureExecutor(executor);
  return executor;
}
718278
def do_execute(self):
        
        if self.storagehandler is None:
            return "No storage handler available!"
        expr = str(self.resolve_option("expression")).replace(
            "{X}", str(self.storagehandler.storage[str(self.resolve_option("storage_name"))]))
        expr = self.storagehandler.expand(expr)
        self.storagehandler.storage[self.resolve_option("storage_name")] = eval(expr)
        self._output.append(self.input)
        return None
644255
def execute(args = [], **options)
      execute_internal(args, options)
      Executor::ExitCode.code(:success)
    rescue Cliqr::Error::CliqrError => e
      puts e.message
      Executor::ExitCode.code(e)
    end