public function testReturnsLazyLoadedDefault()
 {
     $r = new ParserRegistry();
     $c = $r->getParser('cookie');
     $this->assertInstanceOf('Guzzle\\Parser\\Cookie\\CookieParser', $c);
     $this->assertSame($c, $r->getParser('cookie'));
 }

 /**
  * Share session with http server
  *
  * @param  $conn \Ratchet\ConnectionInterface
  */
 public static function get_session(\Ratchet\ConnectionInterface $conn)
 {
     \Session::clear_instances();
     /**
      * Set cookie
      */
     $cookie = $conn->WebSocket->request->getHeader('cookie');
     $data = \Guzzle\Parser\ParserRegistry::getInstance()->getParser('cookie')->parseCookie($cookie);
     $_COOKIE = $data['cookies'];
     /**
      * Set remote address
      */
     $x_forwarded_for = $conn->WebSocket->request->getHeader('x-forwarded-for');
     $_SERVER['REMOTE_ADDR'] = !empty($x_forwarded_for) ? $x_forwarded_for : $conn->remoteAddress;
     /**
      * Set user agent
      * 
      * TODO: How to get user agent like remote address
      */
     \Config::load('session', true);
     \COnfig::set('session.match_ua', false);
     try {
         $session = \Session::forge();
     } catch (\Exception $e) {
         $session = null;
     }
     /**
      * Remove data
      */
     $_SERVER['REMOTE_ADDR'] = null;
     $_COOKIE = null;
     \Session::clear_instances();
     return $session;
 }

 /**
  * @dataProvider testSuiteProvider
  * @covers Aws\Common\Signature\SignatureV4
  * @covers Aws\Common\Signature\AbstractSignature
  */
 public function testSignsRequestsProperly($group)
 {
     $parser = ParserRegistry::getInstance()->getParser('url');
     $parser->setUtf8Support(true);
     // Create a request based on the '.req' file
     $requestString = file_get_contents($group['req']);
     $request = RequestFactory::getInstance()->fromMessage($requestString);
     // Sanitize the request
     $request->removeHeader('User-Agent');
     $request->removeHeader('Content-Length');
     // Sign the request using the test credentials
     $credentials = new Credentials(self::DEFAULT_KEY, self::DEFAULT_SECRET);
     // Get a mock signature object
     $signature = $this->getSignature();
     // Sign the request
     $signature->signRequest($request, $credentials);
     // Get debug signature information
     $context = $request->getParams()->get('aws.signature');
     // Test that the canonical request is correct
     $this->assertEquals(str_replace("\r", '', trim(file_get_contents($group['creq']))), $context['canonical_request']);
     // Test that the string to sign is correct
     $this->assertEquals(str_replace("\r", '', trim(file_get_contents($group['sts']))), $context['string_to_sign']);
     // Test that the authorization header is correct
     $this->assertEquals(str_replace("\r", '', trim(file_get_contents($group['authz']))), (string) $request->getHeader('Authorization'));
     $parser->setUtf8Support(false);
 }

 /**
  * Factory method to create a new URL from a URL string
  *
  * @param string $url Full URL used to create a Url object
  *
  * @return Url
  */
 public static function factory($url)
 {
     $parts = ParserRegistry::getInstance()->getParser('url')->parseUrl($url);
     // Convert the query string into a QueryString object
     if ($parts['query']) {
         $parts['query'] = QueryString::fromString($parts['query']);
     }
     return new self($parts['scheme'], $parts['host'], $parts['user'], $parts['pass'], $parts['port'], $parts['path'], $parts['query'], $parts['fragment']);
 }

 public function testReturnsLazyLoadedDefault()
 {
     // Clear out what might be cached
     $refObject = new \ReflectionClass('Guzzle\\Parser\\ParserRegistry');
     $refProperty = $refObject->getProperty('instances');
     $refProperty->setAccessible(true);
     $refProperty->setValue(null, array());
     $c = ParserRegistry::get('cookie');
     $this->assertInstanceOf('Guzzle\\Parser\\Cookie\\CookieParser', $c);
     $this->assertSame($c, ParserRegistry::get('cookie'));
 }

 public function fromMessage($message)
 {
     $parsed = ParserRegistry::getInstance()->getParser('message')->parseRequest($message);
     if (!$parsed) {
         return false;
     }
     $request = $this->fromParts($parsed['method'], $parsed['request_url'], $parsed['headers'], $parsed['body'], $parsed['protocol'], $parsed['version']);
     if (!isset($parsed['headers']['Expect']) && !isset($parsed['headers']['expect'])) {
         $request->removeHeader('Expect');
     }
     return $request;
 }

 public static function factory($config = array())
 {
     ParserRegistry::getInstance()->registerParser('uri_template', new MyrrixUriTemplate(ParserRegistry::getInstance()->getParser('uri_template')));
     $default = array('base_url' => 'http://{hostname}:{port}', 'hostname' => 'localhost', 'port' => 8080, 'username' => null, 'password' => null);
     $required = array('hostname', 'port', 'base_url', 'username', 'password');
     $config = Collection::fromConfig($config, $default, $required);
     $client = new self($config->get('base_url'), $config);
     $client->setDescription(ServiceDescription::factory(__DIR__ . DIRECTORY_SEPARATOR . 'service.json'));
     $client->setDefaultHeaders(array('Accept' => 'text/html'));
     $authPlugin = new CurlAuthPlugin($config['username'], $config['password']);
     $client->addSubscriber($authPlugin);
     return $client;
 }

 /**
  * Create a new Response based on a raw response message
  *
  * @param string $message Response message
  *
  * @return Response|bool Returns false on error
  */
 public static function fromMessage($message)
 {
     $data = ParserRegistry::get('message')->parseResponse($message);
     if (!$data) {
         return false;
     }
     // Always set the appropriate Content-Length
     unset($data['headers']['Content-Length']);
     unset($data['headers']['content-length']);
     $data['headers']['Content-Length'] = strlen($data['body']);
     $response = new static($data['code'], $data['headers'], $data['body']);
     $response->setProtocol($data['protocol'], $data['version'])->setStatus($data['code'], $data['reason_phrase']);
     return $response;
 }

 public static function fromMessage($message)
 {
     $data = ParserRegistry::getInstance()->getParser('message')->parseResponse($message);
     if (!$data) {
         return false;
     }
     $response = new static($data['code'], $data['headers'], $data['body']);
     $response->setProtocol($data['protocol'], $data['version'])->setStatus($data['code'], $data['reason_phrase']);
     $contentLength = (string) $response->getHeader('Content-Length');
     $actualLength = strlen($data['body']);
     if (strlen($data['body']) > 0 && $contentLength != $actualLength) {
         $response->setHeader('Content-Length', $actualLength);
     }
     return $response;
 }

 /**
  * {@inheritdoc}
  */
 public function fromMessage($message)
 {
     $parsed = ParserRegistry::getInstance()->getParser('message')->parseRequest($message);
     if (!$parsed) {
         return false;
     }
     $request = $this->fromParts($parsed['method'], $parsed['request_url'], $parsed['headers'], $parsed['body'], $parsed['protocol'], $parsed['version']);
     // EntityEnclosingRequest adds an "Expect: 100-Continue" header when using a raw request body for PUT or POST
     // requests. This factory method should accurately reflect the message, so here we are removing the Expect
     // header if one was not supplied in the message.
     if (!isset($parsed['headers']['Expect']) && !isset($parsed['headers']['expect'])) {
         $request->removeHeader('Expect');
     }
     return $request;
 }

 /**
  * {@inheritdoc}
  */
 protected function build()
 {
     $uri = $this->apiCommand->getUri();
     if (!$uri) {
         $url = $this->client->getBaseUrl();
     } else {
         // Get the path values and use the client config settings
         $variables = $this->client->getConfig()->getAll();
         foreach ($this->apiCommand->getParams() as $name => $arg) {
             $configValue = $this->get($name);
             if (is_scalar($configValue)) {
                 $variables[$name] = $arg->getPrepend() . $configValue . $arg->getAppend();
             }
         }
         // Merge the client's base URL with an expanded URI template
         $url = (string) Url::factory($this->client->getBaseUrl())->combine(ParserRegistry::get('uri_template')->expand($uri, $variables));
     }
     // Inject path and base_url values into the URL
     $this->request = $this->client->createRequest($this->apiCommand->getMethod(), $url);
     // Add arguments to the request using the location attribute
     foreach ($this->apiCommand->getParams() as $name => $arg) {
         $location = $arg->getLocation();
         // Visit with the associated visitor
         if (isset($this->visitors[$location])) {
             // Ensure that a value has been set for this parameter
             $configValue = $this->get($name);
             if ($configValue !== null) {
                 // Create the value based on prepend and append settings
                 if ($arg->getPrepend() || $arg->getAppend()) {
                     $value = $arg->getPrepend() . $configValue . $arg->getAppend();
                 } else {
                     $value = $configValue;
                 }
                 // Apply the parameter value with the location visitor
                 $this->visitors[$location]->visit($this, $this->request, $arg->getLocationKey() ?: $name, $value);
             }
         }
     }
     // Call the after method on each visitor
     foreach ($this->visitors as $visitor) {
         $visitor->after($this, $this->request);
     }
 }

 /**
  * {@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;
 }

 public function addCookiesFromResponse(Response $response, RequestInterface $request = null)
 {
     if ($cookieHeader = $response->getHeader('Set-Cookie')) {
         $parser = ParserRegistry::getInstance()->getParser('cookie');
         foreach ($cookieHeader as $cookie) {
             if ($parsed = $request ? $parser->parseCookie($cookie, $request->getHost(), $request->getPath()) : $parser->parseCookie($cookie)) {
                 foreach ($parsed['cookies'] as $key => $value) {
                     $row = $parsed;
                     $row['name'] = $key;
                     $row['value'] = $value;
                     unset($row['cookies']);
                     $this->add(new Cookie($row));
                 }
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function addCookiesFromResponse(Response $response)
 {
     if ($cookieHeader = $response->getSetCookie()) {
         $request = $response->getRequest();
         $parser = ParserRegistry::getInstance()->getParser('cookie');
         foreach ($cookieHeader as $cookie) {
             $parsed = $request ? $parser->parseCookie($cookie, $request->getHost(), $request->getPath()) : $parser->parseCookie($cookie);
             if ($parsed) {
                 // Break up cookie v2 into multiple cookies
                 foreach ($parsed['cookies'] as $key => $value) {
                     $row = $parsed;
                     $row['name'] = $key;
                     $row['value'] = $value;
                     unset($row['cookies']);
                     $this->add(new Cookie($row));
                 }
             }
         }
     }
 }

 /**
  * Create a request for the command and operation
  *
  * @param CommandInterface $command Command to create a request for
  *
  * @return RequestInterface
  */
 protected function createRequest(CommandInterface $command)
 {
     $operation = $command->getOperation();
     $client = $command->getClient();
     // If the command does not specify a template, then assume the base URL of the client
     if (!($uri = $operation->getUri())) {
         return $client->createRequest($operation->getHttpMethod(), $client->getBaseUrl());
     }
     // Get the path values and use the client config settings
     $variables = array();
     foreach ($operation->getParams() as $name => $arg) {
         if ($arg->getLocation() == 'uri') {
             if ($command->hasKey($name)) {
                 $variables[$name] = $arg->filter($command->get($name));
                 if (!is_array($variables[$name])) {
                     $variables[$name] = (string) $variables[$name];
                 }
             }
         }
     }
     // Merge the client's base URL with an expanded URI template
     return $client->createRequest($operation->getHttpMethod(), (string) Url::factory($client->getBaseUrl())->combine(ParserRegistry::getInstance()->getParser('uri_template')->expand($uri, $variables)));
 }

 /**
  * {@inheritdoc}
  */
 protected function build()
 {
     if (!$this->apiCommand->getUri()) {
         $url = $this->getClient()->getBaseUrl();
     } else {
         // Get the path values and use the client config settings
         $variables = $this->getClient()->getConfig()->getAll();
         foreach ($this->apiCommand->getParams() as $name => $arg) {
             $configValue = $this->get($name);
             if (is_scalar($configValue)) {
                 $variables[$name] = $arg->getPrepend() . $configValue . $arg->getAppend();
             }
         }
         // Expand the URI template using the URI values
         $uri = ParserRegistry::get('uri_template')->expand($this->apiCommand->getUri(), $variables);
         // Merge the client's base URL with the URI template
         $url = Url::factory($this->getClient()->getBaseUrl());
         $url->combine($uri);
         $url = (string) $url;
     }
     // Inject path and base_url values into the URL
     $this->request = $this->getClient()->createRequest($this->apiCommand->getMethod(), $url);
     // Add arguments to the request using the location attribute
     foreach ($this->apiCommand->getParams() as $name => $arg) {
         $configValue = $this->get($name);
         $location = $arg->getLocation();
         if (!$configValue || !$location) {
             continue;
         }
         // Create the value based on prepend and append settings
         if ($arg->getPrepend() || $arg->getAppend()) {
             $value = $arg->getPrepend() . $configValue . $arg->getAppend();
         } else {
             $value = $configValue;
         }
         // If a location key mapping is set, then use it
         $key = $arg->getLocationKey() ?: $name;
         // Add the parameter to the request
         switch ($location) {
             case 'body':
                 $this->request->setBody(EntityBody::factory($value));
                 break;
             case 'header':
                 $this->request->setHeader($key, $value);
                 break;
             case 'query':
                 $this->request->getQuery()->set($key, $value);
                 break;
             case 'post_field':
                 $this->request->setPostField($key, $value);
                 break;
             case 'post_file':
                 if ($value instanceof PostFileInterface) {
                     $this->request->addPostFile($value);
                 } else {
                     $this->request->addPostFile($key, $value);
                 }
                 break;
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getUriTemplate()
 {
     if (!$this->uriTemplate) {
         $this->uriTemplate = ParserRegistry::get('uri_template');
     }
     return $this->uriTemplate;
 }

 /**
  * Get the URI template expander used by the client
  *
  * @return UriTemplateInterface
  */
 protected function getUriTemplate()
 {
     if (!$this->uriTemplate) {
         $this->uriTemplate = ParserRegistry::getInstance()->getParser('uri_template');
     }
     return $this->uriTemplate;
 }

 public function getCookies()
 {
     if ($cookie = $this->getHeader('Cookie')) {
         $data = ParserRegistry::getInstance()->getParser('cookie')->parseCookie($cookie);
         return $data['cookies'];
     }
     return array();
 }

 /**
  * Update a request based on the log messages of the CurlHandle
  *
  * @param RequestInterface $request Request to update
  */
 public function updateRequestFromTransfer(RequestInterface $request)
 {
     if (!$request->getResponse()) {
         return;
     }
     // Update the transfer stats of the response
     $request->getResponse()->setInfo($this->getInfo());
     if (!($log = $this->getStderr(true))) {
         return;
     }
     // Parse the cURL stderr output for outgoing requests
     $headers = '';
     fseek($log, 0);
     while (($line = fgets($log)) !== false) {
         if ($line && $line[0] == '>') {
             $headers = substr(trim($line), 2) . "\r\n";
             while (($line = fgets($log)) !== false) {
                 if ($line[0] == '*' || $line[0] == '<') {
                     break;
                 } else {
                     $headers .= trim($line) . "\r\n";
                 }
             }
         }
     }
     // Add request headers to the request exactly as they were sent
     if ($headers) {
         $parsed = ParserRegistry::getInstance()->getParser('message')->parseRequest($headers);
         if (!empty($parsed['headers'])) {
             $request->setHeaders(array());
             foreach ($parsed['headers'] as $name => $value) {
                 $request->setHeader($name, $value);
             }
         }
         if (!empty($parsed['version'])) {
             $request->setProtocolVersion($parsed['version']);
         }
     }
 }