/**
* {@inheritDoc}
*/
public static function fromCommand(CommandInterface $command, Response $response)
{
$errors = json_decode($response->getBody(true), true);
$type = array_get($errors, 'error.type', null);
$code = array_get($errors, 'error.code', null);
$message = array_get($errors, 'error.message', null);
$class = '\\Apache\\Usergrid\\Api\\Exception\\' . studly_case($type) . 'Exception';
if (class_exists($class)) {
$exception = new $class($message, $response->getStatusCode());
} else {
$exception = new static($message, $response->getStatusCode());
}
$exception->setErrorType($type);
$exception->setResponse($response);
$exception->setRequest($command->getRequest());
return $exception;
}
/**
* {@inheritDoc}
*/
public static function fromCommand(CommandInterface $command, Response $response)
{
$errors = json_decode($response->getBody(true), true);
$type = $errors['error']['type'];
$message = isset($errors['error']['message']) ? $errors['error']['message'] : 'Unknown error';
$code = isset($errors['error']['code']) ? $errors['error']['code'] : null;
// We can trigger very specific exception based on the type and code
if ($type === 'card_error') {
$exception = new CardErrorException($message, $response->getStatusCode());
} elseif ($type === 'invalid_request_error' && $code === 'rate_limit') {
$exception = new ApiRateLimitException($message, $response->getStatusCode());
} else {
$exception = new static($message, $response->getStatusCode());
}
$exception->setRequest($command->getRequest());
$exception->setResponse($response);
return $exception;
}
public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, $value)
{
$this->fqname = $command->getName();
$query = array();
$this->customResolver($value, $param, $query, $param->getWireName());
$request->addPostFields($query);
}
protected function handleParsing(CommandInterface $command, Response $response, $contentType)
{
$operation = $command->getOperation();
$type = $operation->getResponseType();
$model = null;
if ($type == OperationInterface::TYPE_MODEL) {
$model = $operation->getServiceDescription()->getModel($operation->getResponseClass());
} elseif ($type == OperationInterface::TYPE_CLASS) {
$responseClassInterface = __NAMESPACE__ . '\\ResponseClassInterface';
$className = $operation->getResponseClass();
if (!class_exists($className)) {
throw new ResponseClassException("{$className} does not exist");
} elseif (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must implement {$responseClassInterface}");
}
return $className::fromCommand($command);
}
if (!$model) {
// Return basic processing if the responseType is not model or the model cannot be found
return parent::handleParsing($command, $response, $contentType);
} elseif ($command[AbstractCommand::RESPONSE_PROCESSING] != AbstractCommand::TYPE_MODEL) {
// Returns a model with no visiting if the command response processing is not model
return new Model(parent::handleParsing($command, $response, $contentType), $model);
} else {
return new Model($this->visitResult($model, $command, $response), $model);
}
}
public function after(CommandInterface $command, RequestInterface $request)
{
$xml = null;
if (isset($this->data[$command])) {
$xml = $this->finishDocument($this->data[$command]);
unset($this->data[$command]);
} else {
$operation = $command->getOperation();
if ($operation->getData('xmlAllowEmpty')) {
$xmlWriter = $this->createRootElement($operation);
$xml = $this->finishDocument($xmlWriter);
}
}
if ($xml) {
if ($this->contentType && !$request->hasHeader('Content-Type')) {
$request->setHeader('Content-Type', $this->contentType);
}
$request->setBody($xml);
}
}
/**
* Create a new model instance from a command.
*
* @param CommandInterface
* @return array
*/
public static function fromCommand(CommandInterface $command)
{
$file = new self();
$file->setParameters($command->getResponse()->json() + array('path' => $command['path']));
$file->finishUpload();
return $file->getParameters();
}
/**
* Allows modules to alter an S3 command after it has been created.
*
* @param \Guzzle\Service\Command\CommandInterface $command
* The command that was created.
*/
function hook_amazons3_command_alter(\Guzzle\Service\Command\CommandInterface $command)
{
if ($command->getName('HeadObject')) {
$command->setOnComplete(function () {
watchdog('amazons3', 'HeadObject was called.');
});
}
}
/**
* @param CommandInterface $command
* @return EncodingResponse
*/
protected function runCommand($command)
{
try {
return $command->getResult();
} catch (\Exception $e) {
throw new RuntimeException('Could not run encoding.com request.', 0, $e);
}
}
/**
* {@inheritdoc}
*/
public function createLinkCommand(CommandInterface $command, Parameter $structure, array $data)
{
$this->validateLink($data);
$this->validateLinkStructure($structure);
$operation = $structure->getData('operation');
$pattern = $structure->getData('pattern');
$params = $this->parseHref($data['href'], $pattern);
return $command->getClient()->getCommand($operation, $params);
}
/**
* {@inheritdoc}
*/
protected function getClassName(CommandInterface $command)
{
// If it's a ListWidgets command, we can iterate over it
if (preg_match('/^List[A-Za-z]+/', $command->getName())) {
return $this->iteratorClassName;
}
// Otherwise, we don't know how to iterate over that command
return null;
}
private function addMd5(CommandInterface $command)
{
$request = $command->getRequest();
if ($body = $request->getBody()) {
if (false !== ($md5 = $body->getContentMd5(true, true))) {
$request->setHeader('Content-MD5', $md5);
}
}
}
/**
* Create a resource iterator
*
* @param CommandInterface $data Command used for building the iterator
* @param array $options Iterator options.
*
* @return ResourceIteratorInterface
*/
public function build($data, array $options = null)
{
if (!$data instanceof CommandInterface) {
throw new InvalidArgumentException('The first argument must be an ' . 'instance of CommandInterface');
}
// Determine the name of the class to load
$className = $this->baseNamespace . '\\' . Inflector::camel($data->getName()) . 'Iterator';
return new $className($data, $options);
}
/**
* {@inheritdoc}
*/
public function before(CommandInterface $command, array &$result)
{
$json = $command->getResponse()->json();
// store links to use later
if (array_key_exists(self::ELEMENT, $json)) {
$this->set($command, 'links', $json[self::ELEMENT]);
}
// create new array of links which visit() adds to
$result[self::ELEMENT] = array();
}
/**
* {@inheritdoc}
*/
public function before(CommandInterface $command, array &$result)
{
$json = $command->getResponse()->json();
// store links to use later
if (array_key_exists($this->getOutputFieldName(), $json)) {
$this->set($command, $this->getFieldName(), $json[$this->getOutputFieldName()]);
}
// create new array of links which visit() adds to
$result[$this->getOutputFieldName()] = array();
}
/**
* {@inheritdoc}
*/
public function factory(CommandInterface $originalCommand, array $data)
{
$command = $this->newCommand();
// set up embedded command
$command->setClient($originalCommand->getClient());
$originalResponse = $originalCommand->getResponse();
$response = $this->createResponse($originalResponse, $data);
$command->setResponse($response);
return $command;
}
private function addMd5(CommandInterface $command)
{
$request = $command->getRequest();
if ($body = $request->getBody()) {
if (false === ($md5 = $body->getContentMd5(true, true))) {
throw new RuntimeException('Unable to add a MD5 checksum');
}
$request->setHeader('Content-MD5', $md5);
}
}
private function createPresignedUrl(AwsClientInterface $client, CommandInterface $command)
{
// Create a temporary client used to generate the presigned URL
$newClient = Ec2Client::factory(array('region' => $command['SourceRegion'], 'signature' => 'v4', 'credentials' => $client->getCredentials()));
$preCommand = $newClient->getCommand('CopySnapshot', $command->toArray());
$preCommand['__internal'] = true;
/** @var \Guzzle\Http\Message\EntityEnclosingRequest $preRequest */
$preRequest = $preCommand->prepare();
return $newClient->getSignature()->createPresignedUrl(SignatureV4::convertPostToGet($preRequest), $newClient->getCredentials(), '+1 hour');
}
public function parse(CommandInterface $command)
{
$response = $command->getRequest()->getResponse();
if ($contentType = $command['command.expects']) {
$response->setHeader('Content-Type', $contentType);
} else {
$contentType = (string) $response->getHeader('Content-Type');
}
return $this->handleParsing($command, $response, $contentType);
}
public function getClassName(CommandInterface $command)
{
$className = $command->getName();
if (isset($this->map[$className])) {
return $this->map[$className];
} elseif (isset($this->map['*'])) {
return $this->map['*'];
}
return null;
}
protected function getClassName(CommandInterface $command)
{
$iteratorName = $this->inflector->camel($command->getName()) . 'Iterator';
foreach ($this->namespaces as $namespace) {
$potentialClassName = $namespace . '\\' . $iteratorName;
if (class_exists($potentialClassName)) {
return $potentialClassName;
}
}
return false;
}
public function parse(CommandInterface $command)
{
$response = $command->getRequest()->getResponse();
// Account for hard coded content-type values specified in service descriptions
if ($contentType = $command['command.expects']) {
$response->setHeader('Content-Type', $contentType);
} else {
$contentType = (string) $response->getHeader('Content-Type');
}
return $this->handleParsing($command, $response, $contentType);
}
/**
* Parse a class object
*
* @param CommandInterface $command Command to parse into an object
*
* @return mixed
* @throws ResponseClassException
*/
protected function parseClass(CommandInterface $command)
{
$className = $command->getOperation()->getResponseClass();
if (!class_exists($className)) {
throw new ResponseClassException("{$className} does not exist");
}
if (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must implement the fromCommand() method");
}
return $className::fromCommand($command);
}
public function getClassName(CommandInterface $command)
{
$className = $command->getName();
if (isset($this->map[$className])) {
return $this->map[$className];
} elseif (isset($this->map['*'])) {
// If a wildcard was added, then always use that
return $this->map['*'];
}
return null;
}
protected function parseClass(CommandInterface $command)
{
$event = new CreateResponseClassEvent(array('command' => $command));
$command->getClient()->getEventDispatcher()->dispatch('command.parse_response', $event);
if ($result = $event->getResult()) {
return $result;
}
$className = $command->getOperation()->getResponseClass();
if (!method_exists($className, 'fromCommand')) {
throw new ResponseClassException("{$className} must exist and implement a static fromCommand() method");
}
return $className::fromCommand($command);
}
/**
* Deserialize the response.
*
* @param CommandInterface $command Command.
* @param Response $response Response.
* @param string $contentType Content type.
*
* @return mixed|null Deserialized response, or `null`.
*/
protected function deserialize(CommandInterface $command, Response $response, $contentType)
{
if ($this->serializer) {
if (false !== stripos($contentType, 'json')) {
$serializerContentType = 'json';
} elseif (false !== stripos($contentType, 'xml')) {
$serializerContentType = 'xml';
} else {
$serializerContentType = null;
}
if (null !== $serializerContentType && OperationInterface::TYPE_CLASS === $command->getOperation()->getResponseType()) {
$context = DeserializationContext::create();
$operation = $command->getOperation();
if (null !== ($groups = $operation->getData('jms_serializer.groups'))) {
$context->setGroups($groups);
}
if (null !== ($version = $operation->getData('jms_serializer.version'))) {
$context->setVersion($version);
}
if (true === $operation->getData('jms_serializer.max_depth_checks')) {
$context->enableMaxDepthChecks();
}
return $this->serializer->deserialize($response->getBody(), $command->getOperation()->getResponseClass(), $serializerContentType, $context);
}
}
return null;
}
/**
* {@inheritdoc}
*
* @param CommandInterface $command
* @return array|MultiResultResponse|SingleResultResponse|Response|mixed
*/
public function parse(CommandInterface $command)
{
$response = $command->getRequest()->getResponse();
if ($response === null) {
return null;
}
$responseArray = $this->parseResponseIntoArray($response);
// If there is no Body, just return the Response
if (!$response->getBody()) {
return $response;
}
// Handle multi-result responses
if (array_key_exists('results', $responseArray)) {
return $this->createMultiResultResponse($response);
}
return $this->createSingleResultResponse($response);
}
/**
* {@inheritdoc}
*/
public function build(CommandInterface $command, array $options = array())
{
// Get the configuration data for the command
$commandName = $command->getName();
$iteratorConfig = $this->operations->get($commandName) ?: array();
$options = array_replace($this->config->getAll(), $iteratorConfig, $options);
// Instantiate the iterator using the primary factory (if there is one)
if ($this->primaryIteratorFactory && $this->primaryIteratorFactory->canBuild($command)) {
$iterator = $this->primaryIteratorFactory->build($command, $options);
} elseif (!$this->operations->hasKey($commandName)) {
throw new InvalidArgumentException("Iterator was not found for {$commandName}.");
} else {
// Fallback to this factory for creating the iterator if the primary factory did not work
$iterator = new AwsResourceIterator($command, $options);
}
return $iterator;
}
public function build(CommandInterface $command, array $options = array())
{
// Get the configuration data for the command
$commandName = $command->getName();
$commandSupported = isset($this->config[$commandName]);
$options = $this->translateLegacyConfigOptions($options);
$options += $commandSupported ? $this->config[$commandName] : array();
// Instantiate the iterator using the primary factory (if one was provided)
if ($this->primaryIteratorFactory && $this->primaryIteratorFactory->canBuild($command)) {
$iterator = $this->primaryIteratorFactory->build($command, $options);
} elseif (!$commandSupported) {
throw new InvalidArgumentException("Iterator was not found for {$commandName}.");
} else {
// Instantiate a generic AWS resource iterator
$iterator = new MssResourceIterator($command, $options);
}
return $iterator;
}
/**
* {@inheritdoc}
*/
public function prepare(CommandInterface $command)
{
$operation = $command->getOperation();
$client = $command->getClient();
$uri = $operation->getUri();
if (!$uri) {
$url = $client->getBaseUrl();
} else {
// Get the path values and use the client config settings
$variables = $client->getConfig()->getAll();
foreach ($operation->getParams() as $name => $arg) {
if ($arg->getLocation() == 'uri' && $command->hasKey($name)) {
$variables[$name] = $command->get($name);
if (!is_array($variables[$name])) {
$variables[$name] = (string) $variables[$name];
}
}
}
// Merge the client's base URL with an expanded URI template
$url = (string) Url::factory($client->getBaseUrl())->combine(ParserRegistry::getInstance()->getParser('uri_template')->expand($uri, $variables));
}
// Inject path and base_url values into the URL
$request = $client->createRequest($operation->getHttpMethod(), $url);
// Add arguments to the request using the location attribute
foreach ($operation->getParams() as $name => $arg) {
/** @var $arg \Guzzle\Service\Description\Parameter */
$location = $arg->getLocation();
// Visit with the associated visitor
if (isset($this->visitors[$location])) {
// Ensure that a value has been set for this parameter
$value = $command->get($name);
if ($value !== null) {
// Apply the parameter value with the location visitor
$this->visitors[$location]->visit($command, $request, $arg, $value);
}
}
}
// Call the after method on each visitor
foreach ($this->visitors as $visitor) {
$visitor->after($command, $request);
}
return $request;
}
/**
* Create a resource iterator
*
* @param CommandInterface $data Command used for building the iterator
* @param array $options Iterator options that are exposed as data.
*
* @return ResourceIteratorInterface
*/
public function build($data, array $options = array())
{
if (!$data instanceof CommandInterface) {
throw new InvalidArgumentException('The first argument must be an instance of CommandInterface');
}
$iteratorName = $this->inflector->camel($data->getName()) . 'Iterator';
// Determine the name of the class to load
$className = null;
foreach ($this->namespaces as $namespace) {
$potentialClassName = $namespace . '\\' . $iteratorName;
if (class_exists($potentialClassName)) {
$className = $potentialClassName;
break;
}
}
if (!$className) {
throw new InvalidArgumentException("Iterator was not found matching {$iteratorName}");
}
return new $className($data, $options);
}