pax_global_header00006660000000000000000000000064124555356010014520gustar00rootroot0000000000000052 comment=2e8286ff81f75f97b00f7dcc2f51e2efafb373bd command-0.7.1/000077500000000000000000000000001245553560100131435ustar00rootroot00000000000000command-0.7.1/LICENSE000066400000000000000000000021271245553560100141520ustar00rootroot00000000000000Copyright (c) 2015 Michael Dowling, https://github.com/mtdowling Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. command-0.7.1/composer.json000066400000000000000000000012421245553560100156640ustar00rootroot00000000000000{ "name": "guzzlehttp/command", "description": "Provides the foundation for building command based web service clients", "license": "MIT", "authors": [ { "name": "Michael Dowling", "email": "mtdowling@gmail.com", "homepage": "https://github.com/mtdowling" } ], "require": { "php": ">=5.4.0", "guzzlehttp/guzzle": "~5.0" }, "require-dev": { "phpunit/phpunit": "~4.0" }, "autoload": { "psr-4": { "GuzzleHttp\\Command\\": "src/" } }, "extra": { "branch-alias": { "dev-master": "0.7-dev" } } } command-0.7.1/src/000077500000000000000000000000001245553560100137325ustar00rootroot00000000000000command-0.7.1/src/AbstractClient.php000066400000000000000000000216571245553560100173600ustar00rootroot00000000000000client = $client; // Ensure the defaults key is an array so we can easily merge later. if (!isset($config['defaults'])) { $config['defaults'] = []; } if (isset($config['emitter'])) { $this->emitter = $config['emitter']; unset($config['emitter']); } $this->config = new Collection($config); } public function __call($name, array $arguments) { return $this->execute( $this->getCommand( $name, isset($arguments[0]) ? $arguments[0] : [] ) ); } public function execute(CommandInterface $command) { $trans = $this->initTransaction($command); if ($trans->result !== null) { return $trans->result; } try { $trans->response = $this->client->send($trans->request); return $trans->response instanceof FutureInterface ? $this->createFutureResult($trans) : $trans->result; } catch (CommandException $e) { // Command exceptions are thrown in the command layer, so throw 'em. throw $e; } catch (\Exception $e) { // Handle when a command result is set after a terminal request // error was encountered. if ($trans->result !== null) { return $trans->result; } $trans->exception = $e; throw $this->createCommandException($trans); } } public function executeAll($commands, array $options = []) { $this->createPool($commands, $options)->wait(); } public function createPool($commands, array $options = []) { return new Pool( $this->client, new CommandToRequestIterator( function (CommandInterface $command) { $trans = $this->initTransaction($command); return [ 'request' => $trans->request, 'result' => $trans->result ]; }, $commands, $options ), isset($options['pool_size']) ? ['pool_size' => $options['pool_size']] : [] ); } public function getHttpClient() { return $this->client; } public function getConfig($keyOrPath = null) { if ($keyOrPath === null) { return $this->config->toArray(); } if (strpos($keyOrPath, '/') === false) { return $this->config[$keyOrPath]; } return $this->config->getPath($keyOrPath); } public function setConfig($keyOrPath, $value) { $this->config->setPath($keyOrPath, $value); } public function createCommandException(CommandTransaction $transaction) { $cn = 'GuzzleHttp\\Command\\Exception\\CommandException'; // Don't continuously wrap the same exceptions. if ($transaction->exception instanceof CommandException) { return $transaction->exception; } if ($transaction->response) { $statusCode = (string) $transaction->response->getStatusCode(); if ($statusCode[0] == '4') { $cn = 'GuzzleHttp\\Command\\Exception\\CommandClientException'; } elseif ($statusCode[0] == '5') { $cn = 'GuzzleHttp\\Command\\Exception\\CommandServerException'; } } return new $cn( "Error executing command: " . $transaction->exception->getMessage(), $transaction, $transaction->exception ); } /** * Prepares a request for the command. * * @param CommandTransaction $trans Command and context to serialize. * * @return RequestInterface */ abstract protected function serializeRequest(CommandTransaction $trans); /** * Creates a future result for a given command transaction. * * This method really should beoverridden in subclasses to implement custom * future response results. * * @param CommandTransaction $transaction * * @return FutureInterface */ protected function createFutureResult(CommandTransaction $transaction) { return new FutureValue( $transaction->response->then(function () use ($transaction) { return $transaction->result; }), // Wait function derefs the response which populates the result. [$transaction->response, 'wait'], [$transaction->response, 'cancel'] ); } /** * Initialize a transaction for a command and send the prepare event. * * @param CommandInterface $command Command to associate with the trans. * * @return CommandTransaction */ protected function initTransaction(CommandInterface $command) { $trans = new CommandTransaction($this, $command); // Throwing in the init event WILL NOT emit an error event. $command->getEmitter()->emit('init', new InitEvent($trans)); $trans->request = $this->serializeRequest($trans); if ($future = $command->getFuture()) { $trans->request->getConfig()->set('future', $future); } $trans->state = 'prepared'; $prep = new PreparedEvent($trans); try { $command->getEmitter()->emit('prepared', $prep); } catch (\Exception $e) { $trans->exception = $e; $trans->exception = $this->createCommandException($trans); } // If the command failed in the prepare event or was intercepted, then // emit the process event now and skip hooking up the request. if ($trans->exception || $prep->isPropagationStopped()) { $this->emitProcess($trans); return $trans; } $trans->state = 'executing'; // When a request completes, process the request at the command // layer. $trans->request->getEmitter()->on( 'end', function (EndEvent $e) use ($trans) { $trans->response = $e->getResponse(); if ($trans->exception = $e->getException()) { $trans->exception = $this->createCommandException($trans); } $this->emitProcess($trans); }, RequestEvents::LATE ); return $trans; } /** * Finishes the process event for the command. */ private function emitProcess(CommandTransaction $trans) { $trans->state = 'process'; try { // Emit the final "process" event for the command. $trans->command->getEmitter()->emit('process', new ProcessEvent($trans)); } catch (\Exception $ex) { // Override any previous exception with the most recent exception. $trans->exception = $ex; $trans->exception = $this->createCommandException($trans); } $trans->state = 'end'; // If the transaction still has the exception, then throw it. if ($trans->exception) { throw $trans->exception; } } } command-0.7.1/src/Command.php000066400000000000000000000031021245553560100160150ustar00rootroot00000000000000name = $name; $this->data = $args; if (isset($options['emitter'])) { $this->emitter = $options['emitter']; } if (isset($options['future'])) { $this->future = $options['future']; } } /** * Ensure that the emitter is cloned. */ public function __clone() { if ($this->emitter) { $this->emitter = clone $this->emitter; } } public function getName() { return $this->name; } public function hasParam($name) { return array_key_exists($name, $this->data); } public function setFuture($useFuture) { $this->future = $useFuture; } public function getFuture() { return $this->future; } } command-0.7.1/src/CommandInterface.php000066400000000000000000000026131245553560100176440ustar00rootroot00000000000000requestBuilder = $requestBuilder; $this->eventListeners = $this->prepareListeners( $options, ['init', 'prepared', 'process'] ); if ($commands instanceof \Iterator) { $this->commands = $commands; } elseif (is_array($commands)) { $this->commands = new \ArrayIterator($commands); } else { throw new \InvalidArgumentException('Command iterators must be ' . 'created using an \\Iterator or array or commands'); } } public function current() { return $this->currentRequest; } public function next() { $this->currentRequest = null; $this->commands->next(); } public function key() { return $this->commands->key(); } public function valid() { get_next: // Return true if this function has already been called for iteration. if ($this->currentRequest) { return true; } // Return false if we are at the end of the provided commands iterator. if (!$this->commands->valid()) { return false; } $command = $this->commands->current(); if (!($command instanceof CommandInterface)) { throw new \RuntimeException('All commands provided to the ' . __CLASS__ . ' must implement GuzzleHttp\\Command\\CommandInterface.' . ' Encountered a ' . Core::describeType($command) . ' value.'); } $command->setFuture('lazy'); $this->attachListeners($command, $this->eventListeners); // Prevent transfer exceptions from throwing. $command->getEmitter()->on( 'process', function (ProcessEvent $e) { if ($e->getException()) { $e->setResult(null); } }, RequestEvents::LATE ); $builder = $this->requestBuilder; $result = $builder($command); // Skip commands that were intercepted with a result. if (isset($result['result'])) { $this->commands->next(); goto get_next; } $this->currentRequest = $result['request']; return true; } public function rewind() { $this->currentRequest = null; if (!($this->commands instanceof \Generator)) { $this->commands->rewind(); } } } command-0.7.1/src/CommandTransaction.php000066400000000000000000000044041245553560100202310ustar00rootroot00000000000000serviceClient = $client; $this->client = $client->getHttpClient(); $this->command = $command; $this->context = new Collection($context); $this->state = 'init'; } } command-0.7.1/src/CommandUtils.php000066400000000000000000000036431245553560100170500ustar00rootroot00000000000000attach($command); } $client->executeAll($commands, RequestEvents::convertEventArray( $options, ['process'], [ 'priority' => RequestEvents::LATE, 'fn' => function (ProcessEvent $e) use ($hash) { if ($e->getException()) { $hash[$e->getCommand()] = $e->getException(); } else { $hash[$e->getCommand()] = $e->getResult(); } } ] )); return new BatchResults($hash); } } command-0.7.1/src/Event/000077500000000000000000000000001245553560100150135ustar00rootroot00000000000000command-0.7.1/src/Event/CommandEvent.php000066400000000000000000000030401245553560100201010ustar00rootroot00000000000000trans = $trans; } /** * Get the command associated with the event * * @return CommandInterface */ public function getCommand() { return $this->trans->command; } /** * Get the service client associated with the command transfer. * * @return ServiceClientInterface */ public function getClient() { return $this->trans->serviceClient; } /** * Get context associated with the command transfer. * * The return value is a Guzzle collection object which can be accessed and * mutated like a PHP associative array. You can add arbitrary data to the * context for application specific purposes. * * @return Collection */ public function getContext() { return $this->trans->context; } /** * Gets the transaction associated with the event * * @return CommandTransaction */ public function getTransaction() { return $this->trans; } } command-0.7.1/src/Event/InitEvent.php000066400000000000000000000003721245553560100174330ustar00rootroot00000000000000request) { throw new StateException('No request on the command transaction'); } $this->trans = $trans; } /** * Gets the HTTP request that will be sent for the command. * * @return RequestInterface */ public function getRequest() { return $this->trans->request; } /** * Set a result on the command transaction to prevent the command from * actually sending an HTTP request. * * Subsequent listeners ARE NOT emitted even when a result is set in the * prepare event. * * @param mixed $result Result to associate with the command */ public function intercept($result) { $this->trans->exception = null; $this->trans->result = $result; $this->stopPropagation(); } /** * Returns the result of the command (if one is available). * * @return mixed|null */ public function getResult() { return $this->trans->result; } } command-0.7.1/src/Event/ProcessEvent.php000066400000000000000000000035231245553560100201470ustar00rootroot00000000000000trans->exception; } /** * Gets the HTTP request that was sent. * * @return RequestInterface */ public function getRequest() { return $this->trans->request; } /** * Get the response that was received for the request if one was received. * * It is important to remember that a response will not be available if the * HTTP request failed with a networking error. * * @return ResponseInterface|null */ public function getResponse() { return $this->trans->response; } /** * Set the processed result on the event. * * Subsequent listeners ARE STILL emitted even when a result is set. * Calling this method will remove any exceptions associated with the * command. * * @param mixed $result Result to associate with the command */ public function setResult($result) { $this->trans->exception = null; $this->trans->result = $result; } /** * Returns the result of the command (if one is available). * * @return mixed|null */ public function getResult() { return $this->trans->result; } } command-0.7.1/src/Exception/000077500000000000000000000000001245553560100156705ustar00rootroot00000000000000command-0.7.1/src/Exception/CommandClientException.php000066400000000000000000000002751245553560100230010ustar00rootroot00000000000000trans = $trans; $request = $trans->request ?: new Request(null, null); $response = $trans->response; parent::__construct($message, $request, $response, $previous); } /** * Gets the service client associated with the failed command. * * @return ServiceClientInterface */ public function getClient() { return $this->trans->serviceClient; } /** * Gets the command that failed. * * @return CommandInterface */ public function getCommand() { return $this->trans->command; } /** * Gets the result of the command if a result was set. * * @return mixed */ public function getResult() { return $this->trans->result; } /** * Gets the context of the command as a collection. * * @return Collection */ public function getContext() { return $this->trans->context; } /** * Gets the transaction associated with the exception. * * @return CommandTransaction */ public function getTransaction() { return $this->trans; } } command-0.7.1/src/Exception/CommandServerException.php000066400000000000000000000002751245553560100230310ustar00rootroot00000000000000getCommand('foo', ['baz' => 'bar'])]; * $client->executeAll($commands); * * @param array|\Iterator $commands Array or iterator that contains * CommandInterface objects to execute. * @param array $options Associative array of options to apply. * @see GuzzleHttp\Command\ServiceClientInterface::createCommandPool for * a list of options. */ public function executeAll($commands, array $options = []); /** * Creates a future object that, when dereferenced, sends commands in * parallel using a fixed pool size. * * Exceptions encountered while executing the commands will not be thrown. * Instead, callers are expected to handle errors using the event system. * * @param array|\Iterator $commands Array or iterator that contains * CommandInterface objects to execute with the client. * @param array $options Associative array of options to apply. * - pool_size: (int) Max number of commands to send concurrently. * When this number of concurrent requests are created, the sendAll * function blocks until all of the futures have completed. * - init: (callable) Receives an InitEvent from each command. * - prepare: (callable) Receives a PrepareEvent from each command. * - process: (callable) Receives a ProcessEvent from each command. * * @return FutureInterface */ public function createPool($commands, array $options = []); /** * Get the HTTP client used to send requests for the web service client * * @return ClientInterface */ public function getHttpClient(); /** * Get a client configuration value. * * @param string|int|null $keyOrPath The Path to a particular configuration * value. The syntax uses a path notation that allows you to retrieve * nested array values without throwing warnings. * * @return mixed */ public function getConfig($keyOrPath = null); /** * Set a client configuration value at the specified configuration path. * * @param string|int $keyOrPath Path at which to change a configuration * value. This path syntax follows the same path syntax specified in * {@see getConfig}. * * @param mixed $value Value to set */ public function setConfig($keyOrPath, $value); /** * Create an exception for a command based on a previous exception. * * This method is invoked when an exception occurs while executing a * command. You may choose to use a custom exception class for exceptions * or return the provided exception as-is. * * @param CommandTransaction $transaction Command transaction context * * @return \Exception */ public function createCommandException(CommandTransaction $transaction); } command-0.7.1/src/Subscriber/000077500000000000000000000000001245553560100160355ustar00rootroot00000000000000command-0.7.1/src/Subscriber/Debug.php000066400000000000000000000302331245553560100175750ustar00rootroot00000000000000states = new \SplObjectStorage(); $this->output = isset($options['output']) ? $options['output'] : fopen('php://output', 'w'); $this->output = Stream::factory($this->output); $this->http = isset($options['http']) ? $options['http'] : true; $this->adapterDebug = isset($options['adapter_debug']) ? $options['adapter_debug'] : true; $this->maxStreamSize = isset($options['max_stream_size']) ? $options['max_stream_size'] : 10240; } public function getEvents() { return [ 'init' => [ ['beforeInit', 'first'], ['afterInit', 'last'] ], 'prepared' => [ ['beforePrepared', 'first'], ['afterPrepared', 'last'] ], 'process' => [ ['beforeProcess', 'first'], ['afterProcess', 'last'] ] ]; } private function write($text) { $this->output->write(date('c') . ': ' . $text . PHP_EOL); } private function hashCommand( ServiceClientInterface $client, CommandInterface $command, EventInterface $event ) { return get_class($client) . '::' . $command->getName() . ' (' . spl_object_hash($event) . ')'; } private function startEvent( $name, $hash, $command, $request = null, $response = null, $result = null, $error = null ) { $last = isset($this->states[$command]) ? $this->states[$command] : null; $this->states[$command] = $this->eventState(func_get_args()); $this->write(sprintf( "Starting the %s event for %s: %s", $name, $hash, $this->diffStates($last, $this->states[$command]) )); } private function endEvent( $name, $hash, $command, $request = null, $response = null, $result = null, $error = null ) { if (!isset($this->states[$command])) { throw new \RuntimeException('Matching start event not found'); } $last = $this->states[$command]; $this->states[$command] = $this->eventState(func_get_args()); $this->write(sprintf( "Done with the %s event for %s (took %f seconds): %s", $name, $hash, microtime(true) - $last['time'], $this->diffStates($last, $this->states[$command]) )); } public function beforeInit(InitEvent $e) { $this->proxyEvent('command:init', $e); } public function afterInit(InitEvent $e) { $this->proxyEvent('command:init', $e); } public function beforePrepared(PreparedEvent $e) { $this->proxyEvent('command:prepared', $e); } public function afterPrepared(PreparedEvent $e) { $this->proxyEvent('command:prepared', $e); $request = $e->getRequest(); if (!$this->http || !$request) { return; } if ($this->adapterDebug) { $request->getConfig()->set('debug', true); } // Attach listeners to request events $before = function ($before) use ($e) { $this->proxyReqEvent('startEvent', $e, $before); }; $after = function ($after) use ($e) { $this->proxyReqEvent('endEvent', $e, $after); }; foreach (['before', 'complete', 'error', 'end'] as $event) { $request->getEmitter()->on($event, $before, RequestEvents::EARLY); $request->getEmitter()->on($event, $after, RequestEvents::LATE); } } public function beforeProcess(ProcessEvent $e) { $this->proxyEvent('command:process', $e); } public function afterProcess(ProcessEvent $e) { $this->proxyEvent('command:process', $e); } /** * Proxies the appropriate call to start or end event * * @param string $name Name of the event * @param EventInterface $e Event to proxy */ public function proxyEvent($name, EventInterface $e) { $meth = substr(debug_backtrace()[1]['function'], 0, 6) == 'before' ? 'startEvent' : 'endEvent'; call_user_func_array( [$this, $meth], [ $name, $this->hashCommand($e->getClient(), $e->getCommand(), $e), $e->getCommand(), method_exists($e, 'getRequest') ? $e->getRequest() : null, method_exists($e, 'getResponse') ? $e->getResponse() : null, method_exists($e, 'getResult') ? $e->getResult() : null, method_exists($e, 'getException') ? $e->getException() : null ] ); } /** * Proxies a call to start or end event based on a request event. * * @param string $meth startEvent or endEvent * @param EventInterface $cev Command event * @param EventInterface $rev Request event */ private function proxyReqEvent( $meth, EventInterface $cev, EventInterface $rev ) { call_user_func( [$this, $meth], $this->getEventName($rev), $this->hashCommand($cev->getClient(), $cev->getCommand(), $rev), $cev->getCommand(), $rev->getRequest(), method_exists($rev, 'getResponse') ? $rev->getResponse() : null, method_exists($cev, 'getResult') ? $cev->getResult() : null, method_exists($cev, 'getError') ? $cev->getError() : null ); } /** * Gets the state of an event as a hash. * * @param array $args Ordered array of arguments passed to an event fn * * @return array */ private function eventState($args) { return [ 'time' => microtime(true), 'command' => $this->toArrayState($args[2]), 'request' => $this->messageState($args[3]), 'response' => $this->messageState($args[4]), 'result' => $this->resultState($args[5]), 'error' => $this->errorState($args[6]) ]; } /** * Calculates the event name of a request event. * * @param EventInterface $event * * @return string */ private function getEventName(EventInterface $event) { $cl = get_class($event); $name = strtolower(substr($cl, strrpos($cl, '\\') + 1)); return 'request:' . substr($name, 0, -5); } /** * Gets the state of a stream as a hash or null. * * If the size of the stream is below the max threshold and the stream is * seekable, then the contents of the stream is included in the hash. * * @param StreamInterface $stream * * @return array|null */ private function streamState(StreamInterface $stream = null) { if (!$stream) { return null; } $result = [ 'class' => get_class($stream), 'size' => $stream->getSize(), 'tell' => $stream->tell() ]; if ($stream->getSize() < $this->maxStreamSize && $stream->isSeekable() ) { $pos = $stream->tell(); $result['contents'] = (string) $stream; $stream->seek($pos); } return $result; } /** * Gets the state of a message as a hash. * * @param MessageInterface $msg * * @return array|null */ private function messageState(MessageInterface $msg = null) { return !$msg ? null : [ 'start-line' => AbstractMessage::getStartLine($msg), 'headers' => AbstractMessage::getHeadersAsString($msg), 'body' => $this->streamState($msg->getBody()) ]; } /** * Converts a ToArrayInterface object into a hash with streams mapped as * needed to hash states. * * @param ToArrayInterface $data * * @return array */ private function toArrayState(ToArrayInterface $data) { $params = $data->toArray(); array_walk_recursive($params, function (&$value) { if ($value instanceof StreamInterface) { $value = $this->streamState($value); } }); $result = [ 'id' => spl_object_hash($data), 'class' => get_class($data), 'keys' => $params ]; if ($data instanceof CommandInterface) { $result['name'] = $data->getName(); } return $result; } /** * Returns the most appropriate JSON encodable value for a result state. * * @param null $result * * @return array|null|string */ private function resultState($result = null) { if ($result === null) { return null; } elseif ($result instanceof ToArrayInterface) { return $this->toArrayState($result); } elseif ($result instanceof StreamInterface) { return $this->streamState($result); } else { return json_encode($result); } } /** * Returns the state of an exception as a hash or null. * * @param \Exception $e * * @return array|null */ private function errorState(\Exception $e = null) { return !$e ? null : [ 'class' => get_class($e), 'message' => $e->getMessage(), 'line' => $e->getLine(), 'file' => $e->getFile(), 'code' => $e->getCode() ]; } /** * Provides a diff between two states as a string */ private function diffStates($a, $b) { if (!$a) { return 'State was changed to ' . print_r($b, true); } unset($a['time'], $b['time']); $diff = $this->diff($a, $b); return $diff ? print_r($diff, true) : 'No change'; } private function diff($a, $b) { $result = []; // Check differences in previous keys foreach ($a as $k => $v) { if (!array_key_exists($k, $b)) { $result[$k . ' was removed, previously'] = $v; } elseif (is_array($v)) { if ($diff = $this->diff($v, $b[$k])) { $result[$k . ' has a change'] = $diff; } } elseif ($v !== $b[$k]) { $result[$k . ' was changed'] = $b[$k]; } } return $result; } } command-0.7.1/src/Subscriber/ResultMock.php000066400000000000000000000044671245553560100206510ustar00rootroot00000000000000addMultiple($results); } public function getEvents() { return ['prepare' => ['onPrepared', 'last']]; } /** * @throws \Exception if one has been queued. * @throws \OutOfBoundsException if the queue is empty. */ public function onPrepared(PreparedEvent $event) { if (!$result = array_shift($this->queue)) { throw new \OutOfBoundsException('Result mock queue is empty'); } elseif ($result instanceof \Exception) { throw $result; } else { $event->intercept($result); } } public function count() { return count($this->queue); } /** * Add a result to the end of the queue. * * @param mixed $result The result of the command. * * @return self */ public function addResult($result) { $this->queue[] = $result; return $this; } /** * Add an exception to the end of the queue. * * @param \Exception $exception Thrown when executing. * * @return self */ public function addException(\Exception $exception) { $this->queue[] = $exception; return $this; } /** * Add multiple results/exceptions to the queue * * @param array $results Results to add * * @return self */ public function addMultiple(array $results) { foreach ($results as $result) { if ($result instanceof \Exception) { $this->addException($result); } else { $this->addResult($result); } } return $this; } /** * Clear the queue. * * @return self */ public function clearQueue() { $this->queue = []; return $this; } }