Queue operation

@param string $operation   Operation
@param array|null $args    Arguments to use as command parameters
@param array $options      Queue options

@return ServiceJob
340040
public function queue($operation, $args = null, $options = [])
	{
		$command = $this->_prepareCommand($operation, $args);
		return $this->broker->queue($command, $options);
	}
799824
public function GetOperation(\Google\Cloud\Container\V1\GetOperationRequest $argument,
      $metadata = [], $options = []) {
        return $this->_simpleRequest('/google.container.v1.ClusterManager/GetOperation',
        $argument,
        ['\Google\Cloud\Container\V1\Operation', 'decode'],
        $metadata, $options);
    }
99994
protected function translate($operation, array $params = [])
    {

        $locale     = is_null($this->locale) ? app()->getLocale() : $this->locale;
        $translator = app('translator');
        if (($name       = $this->notificationContents->find($operation, $locale)) !== false) {
            return $translator->transWith($name, $params);
        }
        return $translator->trans("antares/logger::operations.{$operation}", $params, 'messages', $locale, false);
    }
523153
private function execCommand($operation, array $params)
    {
        // Create the command.
        $command = $this->client->getCommand(
            $this->info['command'][$operation],
            $params + $this->state->getId()
        );

        // Execute the before callback.
        if (is_callable($this->config["before_{$operation}"])) {
            $this->config["before_{$operation}"]($command);
        }

        // Execute the command asynchronously and return the promise.
        return $this->client->executeAsync($command);
    }
99669
public function ExecuteRequest($operation, $params = array())
	{
		$params = array_replace($this->GetWSInitialRequest($operation), $params); 

		$results = parent::ExecuteRequest($operation, $params);

		$this->_CheckErrors($operation, $results);

		return $results->{$operation.'Result'};
	}
503616
public function awaitOperation(Operation $operation, $interval = 5)
    {
        while ($operation->getState() == OperationState::InProgress) {
            $operation = $this->getOperation($operation);
            if ($operation->getState() == OperationState::InProgress) {
                sleep($interval);
            }
        }

        return $operation;
    }
828035
public function remove(OperationState $operation = NULL)
    {
        if (is_null($operation)) {
            array_pop($this->operationQueue);
            return TRUE;
        } else {
            if ($this->isInQueue($operation)) {
                unset($this->operationQueue[$operation->getKey()]);
                return TRUE;
            }
            return FALSE;
        }
    }
73922
public function pushRaw($payload, $queue = null, array $options = [])
    {
        return $this->swoole->task($payload, ! is_numeric($queue) ? -1 : (int)$queue);
    }
1150379
public function execute(array $args, array $options = [])
    {
        if (!isset($args[0])) {
            throw new \InvalidArgumentException('arg action must be input');
        }
        $action = explode('::', $args[0]);
        if (!class_exists($action[0])) {
            throw new \InvalidArgumentException('action not not found!');
        }

        if (isset($args[1])) {
            $frequency = abs(intval($args[1]));
        } else {
            $frequency = null;
        }
        ProcessManage::addTask($action, $frequency);
    }
503291
public function queue($name, array $options = [])
    {
        return $this->queues[$name] = (new QueueBuilder($this, $name))->options($options);
    }
685184
public function queue(string $queueName, JobInterface $job, array $options = []): void
    {
        $queue = $this->queueManager->getQueue($queueName);

        $payload = serialize($job);
        $messageId = $queue->submit($payload, $options);
        $this->emitMessageSubmitted($queue, $messageId, $payload, $options);
    }
561655
protected static function _nestedResourceOperation($method, $url, $params = null, $options = null)
    {
        self::_validateParams($params);

        list($response, $opts) = static::_staticRequest($method, $url, $params, $options);
        $obj = \Stripe\Util\Util::convertToStripeObject($response->json, $opts);
        $obj->setLastResponse($response);
        return $obj;
    }
276142
public function execute($operation, $parameter = array(), $version = null)
    {
        // remove '/' from operation
        $operation = preg_replace('/\//', '', $operation);

        $className = 'RakutenRws_Api_Definition_'.$operation;
        if (!class_exists($className)) {
            throw new LogicException('Operation is not definied.');
        }

        $api = new $className($this, $this->options);
        if ($version !== null) {
            $api->setVersion($version);
        }

        return $api->execute($parameter);
    }
352921
public function execute(array $args = [], array $options = [])
    {
        $sys = new Service\SystemService();
        $g   = new Service\GitService($sys);

        $tag = $g->getNextTag($this->getConfig()->get('minor_version'));

        $g->tag($tag);

        echo sprintf("%s tag created.\n", $tag);
    }
576252
protected function _prepareCommand($operation, $args)
	{
	    $args = ($args) ?:$this->args;
	    $command = new Command($this->service, $operation, $args);
	    
	    if ($this->context) {
	        $command->setContext($this->context);
	    } else {
	        $command->setContext($this->broker->getDefaultContext());
	    }
	    
	    if ($this->identity) {
	        $command->setIdentity($this->identity);
	    } else {
	        $command->setIdentity($this->broker->getDefaultIdentity());
	    }
	    
	    return $command;
	}
1147783
public function execRaw($command, $service = null, $options = [], $quiet = false)
    {
        $container_id = $this->askForServiceContainerId($service);

        return $this->runCommandInContainer($container_id, $command, $options, $quiet);
    }
365672
public function run(array $args = null) {
		$exec = escapeshellcmd($this->command);
		if ($args) {
			$exec .= " ". implode(" ", array_map("escapeshellarg", (array) $args));
		}
		
		if ($this->sudo) {
			$this->suExec(sprintf($this->sudo." 2>&1", $exec), $this->verbose);
		} elseif ($this->verbose) {
			ob_start(function($s) {
				$this->output .= $s;
				return $s;
			}, 1);
			passthru($exec, $this->status);
			ob_end_flush();
		} elseif ($this->verbose !== false /* !quiet */) {
			ob_start([$this, "progress"], 1);
			passthru($exec . " 2>&1", $this->status);
			ob_end_flush();
		} else {
			exec($exec ." 2>&1", $output, $this->status);
			$this->output = implode("\n", $output);
		}
		
		if ($this->status) {
			throw new Exception("Command {$exec} failed ({$this->status})");
		}

		return $this;
	}