public function convert(AbstractTransferEvent $event) { $response = $event->getResponse(); if ($response === null) { return; } $stream = $response->getBody(); if ($stream === null) { // no body - nothing to convert return; } $headers = $response->getHeaders(); // represent the headers as a string foreach ($headers as $name => $values) { $headers[$name] = implode("; ", $values); } $content = $stream->__toString(); $result = $this->converter->convert($headers, $content); if ($result !== null) { $body = new Stream(fopen('php://temp', 'r+')); // see Guzzle 4.1.7 > GuzzleHttp\Adapter\Curl\RequestMediator::writeResponseBody $response->setBody($body); $body->write($result->getTargetContent()); $response->setHeaders($result->getTargetHeaders()); } }
public function __invoke($retries, AbstractTransferEvent $event) { if (!($response = $event->getResponse())) { return RetrySubscriber::DEFER; } if (!$response->hasHeader('x-amz-crc32')) { return RetrySubscriber::DEFER; } $hash = hexdec(Utils::hash($response->getBody(), 'crc32b')); return (int) $response->getHeader('x-amz-crc32') !== $hash ? RetrySubscriber::RETRY : RetrySubscriber::DEFER; }
/** * Save referer to identity before passing the event on to the evaluation function * @param AbstractTransferEvent $event */ public function evaluate(AbstractTransferEvent $event) { $resp = $event->getResponse(); if ($resp != null) { $url = $resp->getEffectiveUrl(); if ($url !== "") { $identity = $this->getCurrentIdentity(); $identity->setReferer($url); } } return parent::evaluate($event); }
public function __invoke($retries, AbstractTransferEvent $event) { // Don't mess with networking errors. if (!($response = $event->getResponse())) { return RetrySubscriber::DEFER; } // Only retry 400 errors that contain the targeted exception message. if ($response->getStatusCode() != 400 || strpos($response->getBody(), self::ERR) === false) { return RetrySubscriber::DEFER; } return RetrySubscriber::RETRY; }
public function __invoke($retries, AbstractTransferEvent $event) { // Doesn't mess with networking errors. if (!($response = $event->getResponse())) { return RetrySubscriber::DEFER; } // Only works on 4xx respsonses if (substr($response->getStatusCode(), 0, 1) != '4') { return RetrySubscriber::DEFER; } $parser = $this->exceptionParser; $parts = $parser($response); return isset(self::$throttlingExceptions[$parts['code']]) ? RetrySubscriber::RETRY : RetrySubscriber::DEFER; }
public function onComplete(AbstractTransferEvent $event) { $request = $event->getRequest(); $retries = (int) $request->getConfig()->get('retries'); if ($retries >= $this->maxRetries) { return; } $filterFn = $this->filter; if (call_user_func_array($filterFn, array($retries, $event))) { $delayFn = $this->delayFn; $sleepFn = $this->sleepFn; call_user_func_array($sleepFn, array(call_user_func_array($delayFn, array($retries, $event)), $event)); $request->getConfig()->set('retries', ++$retries); $event->intercept($event->getClient()->send($request)); } }
/** * @param TransactionInterface $transaction Transaction that contains the request * @param RequestException $e Exception encountered * @param array $transferStats Array of transfer statistics */ public function __construct(TransactionInterface $transaction, RequestException $e, $transferStats = []) { parent::__construct($transaction, $transferStats); $this->exception = $e; }
/** * @param AbstractTransferEvent $event * @throws RotatingProxySubscriberException * @return void */ public function evaluateResult(AbstractTransferEvent $event) { $request = $event->getRequest(); if ($event instanceof ErrorEvent) { $exception = $event->getException(); if ($exception !== null) { do { if ($exception instanceof NoProxiesLeftException) { throw $exception; } $exception = $exception->getPrevious(); } while ($exception !== null); } } $requestId = $request->getConfig()->get(self::$REQUEST_CONFIG_KEY); if ($requestId === null) { return; // Question: What about caches? A cached response might be served so that no proxy was used. // SOLUTION: simply return without exception. // throw new RotatingProxySubscriberException("Config key '".self::$REQUEST_CONFIG_KEY."' not found in request config - this shouldn't happen..."); } if (!array_key_exists($requestId, $this->requestId2ProxyMap)) { // This method really should only be called once, because it determines the result of the proxy request // if it's called multiple times, something is probably wrong. A possible scenario: // Client has a RotatingProxySubscriber and an additional function attached to the complete event that checks wether the // response was logically correct (e.g. contained the right json format) and throws an exception if not. // In that case, this method (evaluateResult) would be called twice: one time in the complete event and the next time // after the exception was thrown (which results in an error event being emitted). // SOLUTION: This can be solved by giving this RotatingProxySubscriber a lower priority so that is called last // Question: Does this introduce problems with ->retry() calls, e.g. is only the last call counted? // Answer: No - see RotatingProxySubscriberTest::test_integration_RetryingRequestsShouldIncreaseFailesAccordingly() $msg = "Request with id '{$requestId}' not found - it was probably already processed. Make sure not to pass on multiple events for the same request. This might be influenced by the event priority."; throw new RotatingProxySubscriberException($msg, $event->getRequest()); } $proxy = $this->requestId2ProxyMap[$requestId]; unset($this->requestId2ProxyMap[$requestId]); $proxy->requested(); // increase request count if ($proxy->evaluate($event)) { $proxy->succeeded(); } else { $proxy->failed(); } }
protected static function getRetryDelay($retries, AbstractTransferEvent $event, $headerName) { if (is_null($event->getResponse()) || !$event->getResponse()->hasHeader($headerName)) { return RetrySubscriber::exponentialDelay($retries, $event); } $retryAfter = $event->getResponse()->getHeader($headerName); if (is_numeric($retryAfter)) { if ($retryAfter < time() - strtotime('1 day', 0)) { return $retryAfter; } else { return $retryAfter - time(); } } if (Utils::isValidDateTimeString($retryAfter, DATE_RFC1123)) { $date = \DateTime::createFromFormat(DATE_RFC1123, $retryAfter); return $date->getTimestamp() - time(); } return RetrySubscriber::exponentialDelay($retries, $event); }