/**
* @param Event $event
*
* @throws PagSeguroException
*/
public function handleError(Event $event)
{
if (!Environment::isValid($event->getRequest()->getHost())) {
return;
}
throw PagSeguroException::create($event->getResponse());
}
public function onError(ErrorEvent $event, $name)
{
$params = Base::parse($event->getResponse());
$response = new \GuzzleHttp\Message\Response(200);
$event->intercept($response);
$event->stopPropagation();
}
public function onError(ErrorEvent $event)
{
//If an error occurs see if data can be served from cache
$request = $event->getRequest();
if ($response = $this->cache->fetch($request->__toString())) {
$event->intercept($response);
}
}
/**
* Method to handle error events.
*
* @param ErrorEvent $event
*/
public function onError(ErrorEvent $event)
{
// Stop measurement and add exception information.
$this->stopMeasure($event->getRequest(), $event->getResponse(), $event->getException());
if ($this->exceptions) {
$this->exceptions->addException($event->getException());
}
}
public function onError(ErrorEvent $event)
{
// Only track when no response is present, meaning this didn't ever
// emit a complete event
if (!$event->getResponse()) {
$this->add($event->getRequest());
}
}
public function testInterceptsWithEvent()
{
$t = new Transaction(new Client(), new Request('GET', '/'));
$except = new RequestException('foo', $t->request);
$t->exception = $except;
$e = new ErrorEvent($t);
$this->assertSame($e->getException(), $t->exception);
}
public function onError(ErrorEvent $event, $name)
{
if ($event->getResponse()->getStatusCode() == 401) {
$params = ['userName' => $this->credentials->getUsername(), 'password' => $this->credentials->getPassword(), 'createPersistentCookie' => 'false'];
$this->commandClient->getCookie($params, ['http' => ['cookies' => true]]);
$newResponse = $event->getClient()->send($event->getRequest());
// Intercept the original transaction with the new response
$event->intercept($newResponse);
}
}
/**
* @param ErrorEvent $event
*/
public function onError(ErrorEvent $event)
{
if ($this->logger) {
$request = $event->getRequest();
$response = $event->getResponse();
$responseBody = $response ? (string) $response->getBody() : null;
$responseHeaders = $response ? $response->getHeaders() : null;
$this->logger->info($this->formatMessage($request->getMethod(), $request->getUrl()), ['requestHeaders' => $request->getHeaders(), 'requestBody' => (string) $request->getBody(), 'responseHeaders' => $responseHeaders, 'responseBody' => $responseBody]);
}
}
public function onError(ErrorEvent $event)
{
$request = $event->getRequest();
$url = $request->getUrl();
if (!$this->stopwatch->isStarted($url)) {
return;
}
$stopwatchEvent = $this->stopwatch->stop($url);
$this->add($request, $event->getResponse(), $stopwatchEvent);
}
public function onError(ErrorEvent $event)
{
if ($event->getResponse()) {
$this->log->error('guzzle_error: ' . $event->getException()->getMessage());
} else {
$ex = $event->getException();
$this->log->error($ex->getMessage() . ' -- ' . $ex->getTraceAsString(), [$ex->getCode(), $ex->getLine(), $ex->getFile()]);
}
$event->stopPropagation();
}
public function testInterceptsWithEvent()
{
$client = new Client();
$request = new Request('GET', '/');
$response = new Response(404);
$transaction = new Transaction($client, $request);
$except = new RequestException('foo', $request, $response);
$event = new ErrorEvent($transaction, $except);
$event->throwImmediately(true);
$this->assertTrue($except->getThrowImmediately());
$event->throwImmediately(false);
$this->assertFalse($except->getThrowImmediately());
$this->assertSame($except, $event->getException());
$this->assertSame($response, $event->getResponse());
$this->assertSame($request, $event->getRequest());
$res = null;
$request->getEmitter()->on('complete', function ($e) use(&$res) {
$res = $e;
});
$good = new Response(200);
$event->intercept($good);
$this->assertTrue($event->isPropagationStopped());
$this->assertSame($res->getClient(), $event->getClient());
$this->assertSame($good, $res->getResponse());
}
public function onError(ErrorEvent $event)
{
$request = $event->getRequest();
if (!$this->canCacheRequest($request)) {
return;
}
$response = $this->storage->fetch($request);
if ($response) {
$request->getConfig()->set('cache_hit', 'ERROR');
$event->intercept($response);
}
}
/**
* @inheritdoc
*/
public function onError(ErrorEvent $event)
{
$response = $event->getResponse();
if ($response && 401 == $response->getStatusCode()) {
$request = $event->getRequest();
if ($request->getConfig()->get('auth') == 'oauth2' && !$request->getConfig()->get('retried')) {
if ($token = $this->acquireAccessToken()) {
$this->accessToken = $token;
$request->getConfig()->set('retried', true);
$event->intercept($event->getClient()->send($request));
}
}
}
}
public function onError(ErrorEvent $event)
{
$params = Base::parse($event->getResponse());
if (isset($params['error']['code'])) {
//invalid session possibly, let's reset the token
if ($params['error']['code'] == 100) {
$this->service->resetAccessToken();
}
}
\Log::info('Facebook Error: ' . (string) $event->getResponse()->getBody());
$response = new \GuzzleHttp\Message\Response(200);
$event->intercept($response);
$event->stopPropagation();
}
/**
* Request error event handler.
*
* Handles unauthorized errors by acquiring a new access token and
* retrying the request.
*
* @param ErrorEvent $event Event received
*/
public function onError(ErrorEvent $event)
{
if (!$event->getResponse() || $event->getResponse()->getStatusCode() == 401) {
if ($event->getRequest()->getHeader('X-Guzzle-Retry')) {
// We already retried once, give up.
return;
}
// Acquire a new access token, and retry the request.
$this->acquireAccessToken();
if ($this->tokenData->accessToken) {
$newRequest = clone $event->getRequest();
$this->accessTokenSigner->sign($newRequest, $this->tokenData->accessToken);
$newRequest->setHeader('X-Guzzle-Retry', '1');
$event->intercept($event->getClient()->send($newRequest));
}
}
}
/**
* {@inheritDoc}
*/
public function onRequestError(ErrorEvent $event)
{
$request = $event->getRequest();
$hasResponse = $event->hasResponse();
if ($hasResponse) {
$response = $event->getResponse();
if ($this->isClientError($response) || $this->isServerError($response)) {
$remaining = (string) $response->getHeader('X-RateLimit-Remaining');
if (null != $remaining && 1 > $remaining && 'rate_limit' !== substr($request->getResource(), 1, 10)) {
throw new ApiLimitExceedException($this->options['api_limit'], $request);
}
$content = ResponseMediator::getContent($response);
if (is_array($content) && isset($content['message'])) {
if (401 == $response->getStatusCode()) {
throw new InvalidTokenException("Your authentication token is invalid", $request);
} elseif (400 == $response->getStatusCode() && isset($content['errors'])) {
if (isset($content['errors']['subject']) && $content['errors']['subject'] === 'token') {
throw new InvalidTokenException("Your authentication token is missing", $request);
}
$errors = array();
foreach ($content['errors'] as $error) {
switch ($error['type']) {
case 'missing_param':
$errors[] = sprintf("The following error occurred: '%s' for parameter '%s'", $error['description'], $error['param']);
break;
case 'duplicate_param':
$errors[] = sprintf("'%s', for parameter '%s'", $error['description'], $error['param']);
break;
case 'invalid_param':
$errors[] = sprintf("This field '%s' contains an invalid parameter; '%s'", $error['param'], $error['description']);
break;
default:
$errors[] = $content['message'];
break;
}
}
throw new ValidationFailedException('Validation Failed: ' . implode("\n", $errors), $request, $response);
} elseif (404 == $response->getStatusCode()) {
throw new NotFoundException($content['message'], $request, $response);
}
}
throw new RuntimeException("Another Error Occurred: " . $content['message'], $request, $response);
}
}
}
/**
*
* @param ErrorEvent $event
*/
public function onError(ErrorEvent $event)
{
$ex = $event->getException();
$this->logger->log(LogLevel::CRITICAL, $this->formatter->format($event->getRequest(), $event->getResponse(), $ex), ['request' => $event->getRequest(), 'response' => $event->getResponse(), 'exception' => $ex]);
$this->rewindResponse($event->getResponse());
}
/**
* Prevent a request from sending and intercept it's complete event.
*
* This method is required when a request fails before sending to prevent
* adapters from still transferring the request over the wire.
*/
private static function stopRequestError(ErrorEvent $e)
{
$fn = function ($ev) {
/** @noinspection PhpUndefinedMethodInspection */
$ev->stopPropagation();
};
$e->getRequest()->getEmitter()->once('complete', $fn, 'first');
$e->intercept(new CanceledResponse());
}
/**
* Prevent a request from sending and intercept it's complete event.
*
* This method is required when a request fails before sending to prevent
* adapters from still transferring the request over the wire.
*/
private static function stopRequestError(ErrorEvent $e)
{
$fn = function ($ev) {
$ev->stopPropagation();
};
$e->getRequest()->getEmitter()->once('complete', $fn, 'first');
$e->intercept(new CanceledResponse());
}
/**
* If the request failed, then check if a cached response would suffice.
*
* @param ErrorEvent $event
*/
public function onError(ErrorEvent $event)
{
$request = $event->getRequest();
if (!call_user_func($this->canCache, $request)) {
return;
}
$response = $this->storage->fetch($request);
// Intercept the failed response if possible
if ($response && $this->validateFailed($request, $response)) {
$request->getConfig()->set('cache_hit', 'error');
$response->setHeader('Age', Utils::getResponseAge($response));
$event->intercept($response);
}
}
private function logErroneousState(ErrorEvent $event)
{
if (!$this->logger) {
return;
}
$url = $event->getTransferInfo(CURLINFO_EFFECTIVE_URL);
$this->logger->critical(sprintf('Call to %s failed.', $url));
}
/**
* @param ErrorEvent $event
*/
public function onError(ErrorEvent $event)
{
$this->onEnd($event->getRequest(), $event->getResponse());
}
public function onError(ErrorEvent $event)
{
$this->logIt($event->getRequest(), $event->getResponse(), $event->getException());
}
