/**
  * Actual health check logic.
  *
  * @param HealthBuilder $builder
  *
  * @throws \Exception any Exception that should create a Status::DOWN
  *                    system status.
  */
 protected function doHealthCheck(HealthBuilder $builder)
 {
     /** @var Response $response */
     $response = $this->request->send();
     $builder->withDetail('statusCode', $response->getStatusCode());
     if (!$response->isSuccessful()) {
         $builder->down()->withDetail('body', $response->getBody(true));
         return;
     }
     $builder->up();
 }
 /**
  * @param Request $request
  * @return array|null
  * @throws BadResponseException
  * @throws FormatException
  */
 protected function proceedResponse(Request $request)
 {
     try {
         $response = $request->send();
     } catch (ClientErrorResponseException $e) {
         $response = $e->getResponse();
     }
     $body = $response->getBody(true);
     if (empty($body) && $response->getStatusCode() >= 200 && $response->getStatusCode() < 300) {
         return null;
     }
     $result = json_decode($body, true);
     if ($result === null) {
         # When response is just a sting.
         $result = $body;
     }
     if ($response->getStatusCode() >= 200 && $response->getStatusCode() < 300) {
         return $result;
     }
     if (!$result || !$result['error']) {
         throw new FormatException('Not valid error response', 3, null, $request, $response);
     }
     $message = $result['error']['message'];
     $code = $result['error']['code'];
     if ($response->getStatusCode() == 429) {
         throw new RateLimitException($message, $code, null, $request, $response);
     }
     $e = new BadResponseException($message, $code, null, $request, $response);
     $e->setError($result['error']);
     throw $e;
 }
示例#3
0
 private function resolveRequest(\Guzzle\Http\Message\Request $request)
 {
     try {
         $this->lastResponse = $request->send();
     } catch (\Guzzle\Http\Exception\TooManyRedirectsException $tooManyRedirectsException) {
         if ($this->hasRequestHistory($request)) {
             $this->lastResponse = $this->getRequestHistory($request)->getLastResponse();
         } else {
             return $request->getUrl();
         }
     } catch (\Guzzle\Http\Exception\BadResponseException $badResponseException) {
         if ($this->getConfiguration()->getRetryWithUrlEncodingDisabled() && !$this->getConfiguration()->getHasRetriedWithUrlEncodingDisabled()) {
             $this->getConfiguration()->setHasRetriedWithUrlEncodingDisabled(true);
             return $this->resolveRequest($this->deEncodeRequestUrl($request));
         } else {
             $this->lastResponse = $badResponseException->getResponse();
         }
     }
     if ($this->getConfiguration()->getHasRetriedWithUrlEncodingDisabled()) {
         $this->getConfiguration()->setHasRetriedWithUrlEncodingDisabled(false);
     }
     if ($this->getConfiguration()->getFollowMetaRedirects()) {
         $metaRedirectUrl = $this->getMetaRedirectUrlFromLastResponse();
         if (!is_null($metaRedirectUrl) && !$this->isLastResponseUrl($metaRedirectUrl)) {
             return $this->resolve($metaRedirectUrl);
         }
     }
     return $this->lastResponse->getEffectiveUrl();
 }
示例#4
0
 /**
  * Function to send the request to the remote API
  *
  * @return  \Trucker\Responses\Response
  */
 public function sendRequest()
 {
     try {
         $response = $this->request->send();
     } catch (\Guzzle\Http\Exception\BadResponseException $e) {
         $response = $e->getResponse();
     }
     return $this->app->make('trucker.response')->newInstance($this->app, $response);
 }
示例#5
0
 public function request(Request $request)
 {
     try {
         $response = $request->send();
     } catch (\Exception $e) {
         throw new ApiException($e->getMessage(), $e->getCode(), $e);
     }
     $apiResponse = new ApiResponse($response->getBody(), $response->getStatusCode(), $response->getContentType());
     return $apiResponse;
 }
 public function send()
 {
     try {
         return parent::send();
     } catch (BadResponseException $e) {
         $response = $e->getResponse();
         $data = json_decode($response->getBody());
         throw new GroongaException($data[0][3]);
     }
 }
 /**
  * Executing service description defined operations returns the result
  * @group unit
  */
 public function testMagicOperationsReturnResult()
 {
     $responseData = array("this" => "that");
     Phockito::when($this->mockResponse->getStatusCode())->return(200);
     Phockito::when($this->mockResponse->json())->return($this->testDescription);
     Phockito::when($this->mockRequest->send())->return($this->mockResponse);
     Phockito::when($this->client)->get(anything())->return($this->mockRequest);
     Phockito::when($this->client)->callParent(anything(), anything())->return($responseData);
     $result = $this->client->SomeOperation(array());
     $this->assertEquals($result, $responseData);
 }
示例#8
0
 /**
  * @covers Guzzle\Http\Message\Request::getResponse
  * @covers Guzzle\Http\Message\Request::processResponse
  * @covers Guzzle\Http\Message\Request::getResponseBody
  */
 public function testRequestThrowsExceptionOnBadResponse()
 {
     try {
         $this->request->setResponse(new Response(404, array('Content-Length' => 3), 'abc'), true);
         $this->request->send();
         $this->fail('Expected exception not thrown');
     } catch (BadResponseException $e) {
         $this->assertInstanceOf('Guzzle\\Http\\Message\\RequestInterface', $e->getRequest());
         $this->assertInstanceOf('Guzzle\\Http\\Message\\Response', $e->getResponse());
         $this->assertContains('Client error response', $e->getMessage());
     }
 }
示例#9
0
 /**
  * Load request sources
  *
  * @param $source
  * @return Export
  */
 public function loadSource($source = '')
 {
     empty($source) === false ? $this->setSource($source) : null;
     $client = new Client($this->source, $this->options);
     $this->request = $client->createRequest();
     try {
         $this->response = $this->request->send();
     } catch (ResponseException $e) {
         throw new BadResponseException($e->getMessage(), $e->getCode());
     }
     return $this;
 }
示例#10
0
 /**
  * Function to send the request to the remote API
  *
  * @return  \Trucker\Responses\Response
  */
 public function sendRequest()
 {
     try {
         $response = $this->request->send();
     } catch (\Guzzle\Http\Exception\BadResponseException $e) {
         $response = $e->getResponse();
     }
     if (Config::get('request.debug', false)) {
         echo 'Request Method: ' . $this->request->getMethod() . "\n";
         echo "Body: " . $response->getBody() . "\n";
         echo "Status Code: " . $response->getStatusCode() . "\n";
         echo "URL: " . $this->request->getUrl() . "\n\n";
     }
     return $this->app->make('trucker.response')->newInstance($this->app, $response);
 }
示例#11
0
 /**
  * @return \Sokil\Rest\Client\Response
  */
 public function send()
 {
     try {
         // disbatch beforeSend event
         $this->_request->getEventDispatcher()->dispatch('onBeforeSend', new \Guzzle\Common\Event(array('request' => $this)));
         // create response
         $this->_response = new Response($this->_request->send(), $this->_structureClassName);
         // trigger event
         $this->_request->getEventDispatcher()->dispatch('onParseResponse', new \Guzzle\Common\Event(array('request' => $this, 'response' => $this->_response)));
         // log
         if ($this->hasLogger()) {
             $this->getLogger()->debug((string) $this->_request . PHP_EOL . (string) $this->_request->getResponse());
         }
         return $this->_response;
     } catch (\Exception $e) {
         if ($this->hasLogger()) {
             $this->getLogger()->debug((string) $e);
         }
         throw $e;
     }
 }
示例#12
0
 /**
  * @When /^I request "(GET|PUT|POST|DELETE|PATCH) ([^"]*)"$/
  */
 public function iRequest($httpMethod, $resource)
 {
     // process any %battles.last.id% syntaxes
     $resource = $this->processReplacements($resource);
     $this->resource = $resource;
     // reset the response payload
     $this->responsePayload = null;
     $method = strtolower($httpMethod);
     try {
         switch ($httpMethod) {
             case 'PUT':
             case 'POST':
             case 'PATCH':
                 // process any %user.weaverryan.id% syntaxes
                 $payload = $this->processReplacements($this->requestPayload);
                 $this->lastRequest = $this->client->{$method}($resource, null, $payload);
                 break;
             default:
                 $this->lastRequest = $this->client->{$method}($resource);
         }
         if ($this->authUser) {
             $this->lastRequest->setAuth($this->authUser, $this->authPassword);
         }
         foreach ($this->headers as $key => $val) {
             $this->lastRequest->setHeader($key, $val);
         }
         $this->response = $this->lastRequest->send();
     } catch (BadResponseException $e) {
         $response = $e->getResponse();
         // Sometimes the request will fail, at which point we have
         // no response at all. Let Guzzle give an error here, it's
         // pretty self-explanatory.
         if ($response === null) {
             throw $e;
         }
         $this->response = $e->getResponse();
     }
 }
示例#13
0
 /**
  * @param \Guzzle\Http\Message\Request $request
  * @return \Guzzle\Http\Message\Response
  */
 public function send(\Guzzle\Http\Message\Request $request)
 {
     $token = $this->getToken();
     $request->setHeader('X-Auth-Token', $token['token'])->setHeader('Content-Type', 'application/json')->setHeader('X-Auth-UserId', $token['user_id']);
     return $request->send();
 }
 /**
  * @param string $uri
  * @param array $headers
  * @param string $postBody
  * @param array $options
  * @return array|\Guzzle\Http\Message\Response
  */
 public function post($uri, $headers = [], $postBody = null, $options = [])
 {
     $this->request = $this->client->post($uri, $headers, $postBody, $options);
     $this->response = $this->request->send();
     return $this->response;
 }
示例#15
0
 /**
  * Get the response from the prepared request.
  *
  * @param \Guzzle\Http\Message\Request $request
  *
  * @return array
  */
 protected function getResponse($request)
 {
     try {
         $response = json_decode($request->send()->getBody(), true);
         return $response['response'];
     } catch (BadResponseException $bre) {
         return;
     }
 }
示例#16
0
 /**
  * @param \Guzzle\Http\Message\Request $xml
  */
 public function __construct(Request $request)
 {
     $this->client = $request->getClient();
     $this->xml = $request->send()->xml();
 }
示例#17
0
 /**
  * @param Request $request
  *
  * @param string  $body
  *
  * @throws \Elasticsearch\Common\Exceptions\TransportException
  * @return \Guzzle\Http\Message\Response
  */
 private function sendRequest(Request $request, $body)
 {
     try {
         $request->send();
     } catch (ServerErrorResponseException $exception) {
         $this->process5xxError($request, $exception, $body);
     } catch (ClientErrorResponseException $exception) {
         $this->process4xxError($request, $exception, $body);
     } catch (CurlException $exception) {
         $this->processCurlError($exception);
     } catch (\Exception $exception) {
         $error = 'Unexpected error: ' . $exception->getMessage();
         $this->log->critical($error);
         throw new TransportException($error);
     }
     $this->processSuccessfulRequest($request, $body);
     return $request->getResponse();
 }
 /**
  * @covers Guzzle\Http\Plugin\CookiePlugin
  */
 public function testAddsCookiesToRequests()
 {
     ArrayCookieJarTest::addCookies($this->storage);
     $this->storage->save(array('domain' => '.y.example.com', 'path' => '/acme/', 'cookie' => array('secure', 'sec'), 'expires' => Guzzle::getHttpDate('+1 day'), 'secure' => true));
     // Add a cookie that is only set on a specific port, so it wont be
     // added to the following requests
     $this->storage->save(array('domain' => '.y.example.com', 'path' => '/acme/', 'cookie' => array('test', 'port'), 'expires' => Guzzle::getHttpDate('+1 day'), 'secure' => false, 'port' => array(8192)));
     $request1 = new Request('GET', 'https://a.y.example.com/acme/');
     $request1->setClient(new Client());
     $request2 = new Request('GET', 'https://a.y.example.com/acme/');
     $request2->setClient(new Client());
     $request3 = new Request('GET', 'http://a.y.example.com/acme/');
     $request3->setClient(new Client());
     $request4 = new Request('GET', 'http://a.y.example.com/acme/');
     $request4->setClient(new Client());
     $request1->getEventDispatcher()->addSubscriber($this->plugin);
     $request2->getEventDispatcher()->addSubscriber($this->plugin);
     $request3->getEventDispatcher()->addSubscriber($this->plugin);
     $request4->getEventDispatcher()->addSubscriber($this->plugin);
     // Set a secure cookie
     $response1 = Response::fromMessage("HTTP/1.1 200 OK\r\nSet-Cookie: a=b; c=d; Max-Age=86400; domain=.example.com; secure;\r\n\r\n");
     // Set a regular cookie
     $response2 = Response::fromMessage("HTTP/1.1 200 OK\r\nSet-Cookie: e=f h; discard; domain=.example.com;\r\n\r\n");
     $response3 = Response::fromMessage("HTTP/1.1 200 OK\r\n\r\n");
     $request1->setResponse($response1, true);
     $request2->setResponse($response2, true);
     $request3->setResponse($response3, true);
     $request1->send();
     $request2->send();
     $request3->send();
     $this->assertEquals('muppet=cookie_monster;secure=sec', (string) $request1->getCookie());
     $this->assertEquals('muppet=cookie_monster;secure=sec;a=b;c=d', (string) $request2->getCookie());
     $this->assertEquals('muppet=cookie_monster;e=f h', (string) $request3->getCookie());
     // Clear the e=f h temporary cookie
     $this->plugin->clearTemporaryCookies();
     $request4->setResponse($response3, true);
     $request4->send();
     $this->assertEquals('muppet=cookie_monster', (string) $request4->getCookie());
 }
 function it_should_return_wgs84_information(Response $response, Request $request)
 {
     // mocks
     $request->send()->willReturn($response);
     $this->client->get(Argument::any())->willReturn($request);
     $response->getStatusCode()->willReturn(200);
     $response->getBody(true)->willReturn('{"success":true,"resource":{"street":"Wilhelminapark",
         "house_number":21,
         "postcode":"5041EB",
         "town":"Tilburg",
         "municipality":"Tilburg",
         "province":"Noord-Brabant",
         "latitude":51.9401,
         "longitude":5.61531,
         "x":133504,
         "y":397543}}');
     $latitude = 51.5664;
     $longitude = 5.07718;
     $this->wgs84($latitude, $longitude)->shouldReturnAnInstanceOf('Niborb\\PostcodeAPI\\Client\\Response');
 }
示例#20
0
 public function send(Request $request)
 {
     try {
         return $request->send()->json();
     } catch (GuzzleHttpException $ex) {
         throw SiftHttpException::fromGuzzleException($ex);
     }
 }
 /**
  * Returns a Response object
  *
  * @param Guzzle\Http\Message\Request $request
  *
  * @return array|Guzzle\Http\Message\Response
  */
 private function doRequest(Request $request)
 {
     try {
         return $request->send();
     } catch (ClientErrorResponseException $e) {
         return $e->getResponse();
     }
 }
示例#22
0
 protected function sendRequest(Request $request)
 {
     try {
         return $request->send()->json();
     } catch (BadResponseException $e) {
         $response = $e->getResponse()->getBody(true);
         throw new CapsideaException("Error in capsidea response: {$response}", 0, $e);
     }
 }
示例#23
0
 /**
  * @param \Guzzle\Http\Client $client
  * @param \Guzzle\Http\Message\Request $request
  * @param \Guzzle\Http\Message\Response $response
  */
 function let($client, $request, $response)
 {
     $this->beConstructedWith('*****@*****.**', 'password', $client);
     $request->send()->willReturn($response);
 }