public function getStackFunction()
{
return Middleware::mapRequest(function (RequestInterface $request) {
// Notice that we have to return a request object
return $request->withHeader('X-Vault-Token', $this->_token);
});
}
public function testSSO()
{
$pid = Helper::getSomeProject();
$user = Helper::getSomeUser();
Helper::getClient()->getProjects()->addUser($pid, $user['uid']);
$targetUrl = "/#s=/gdc/projects/{$pid}|projectDashboardPage";
$sso = new SSO(null, null, KBGDC_API_URL);
$ssoLink = $sso->getUrl(KBGDC_USERNAME, KBGDC_SSO_KEY, KBGDC_SSO_PROVIDER, $targetUrl, $user['email'], 3600, KBGDC_SSO_KEY_PASS);
$stack = \GuzzleHttp\HandlerStack::create();
$lastRequest = null;
$stack->push(\GuzzleHttp\Middleware::mapRequest(function (Request $request) use(&$lastRequest) {
$lastRequest = $request;
return $request;
}));
$client = new Client(['handler' => $stack, \GuzzleHttp\RequestOptions::ALLOW_REDIRECTS => true, 'verify' => false]);
try {
$client->request('GET', $ssoLink, ['headers' => ['Accept' => 'application/json']]);
} catch (RequestException $e) {
if ($e->hasResponse()) {
$response = $e->getResponse()->getBody();
$this->fail("{$response} on link: {$ssoLink}");
} else {
$this->fail($e->getMessage() . " on link: {$ssoLink}");
}
}
/** @var Request $lastRequest */
$result = $lastRequest->getUri()->__toString();
$this->assertStringEndsWith($targetUrl, urldecode($result));
}
/**
* @param string $id
* @param string $secret
* @param string $url
*/
public function __construct($id, $secret, $url)
{
$this->logger = new NullLogger();
if (!strlen($id) || !strlen($secret)) {
throw new InvalidArgumentException('api_id and api_secret must both be provided');
}
$validatedUrl = filter_var($url, FILTER_VALIDATE_URL);
if (!$validatedUrl) {
throw new InvalidArgumentException($url . ' is not a valid URL');
}
$this->id = $id;
$this->secret = $secret;
$this->baseUrl = $validatedUrl . '/page/api/';
$handlerStack = HandlerStack::create(GuzzleHttp\choose_handler());
$handlerStack->push(Middleware::mapRequest(function (RequestInterface $request) {
$uri = $request->getUri();
$query = new Query($uri->getQuery());
/*
* Add id and version to the query
*/
$query = $query->merge(Query::createFromArray(['api_id' => $this->id, 'api_ver' => '2']));
/*
* Add timestamp to the query
*/
if (!$query->hasKey('api_ts')) {
$query = $query->merge(Query::createFromArray(['api_ts', time()]));
}
$query = $query->merge(Query::createFromArray(['api_mac' => $this->generateMac($uri->getPath(), $query)]));
return $request->withUri($uri->withQuery((string) $query));
}));
$this->guzzleClient = new GuzzleClient(['handler' => $handlerStack]);
}
private function createAuthStack()
{
$stack = HandlerStack::create();
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
return $request->withHeader('Authorization', "Bearer " . $this->accessToken);
}));
return $stack;
}
public static function get(array $options, $key)
{
$stack = HandlerStack::create();
$stack->unshift(Middleware::mapRequest(function (RequestInterface $request) use($key) {
return $request->withUri(Uri::withQueryValue($request->getUri(), 'key', $key));
}));
$options['handler'] = $stack;
return new Client($options);
}
/**
* @return callable
*/
public function getCallable()
{
return Middleware::mapRequest(function (RequestInterface $request) {
if ($request->hasHeader(AbstractHttpClient::HEADER_HOST_YVES)) {
$this->getLogger()->info(sprintf('Transfer request [%s] %s', $request->getMethod(), $request->getRequestTarget()), ['guzzle-body' => $request->getBody()->getContents()]);
}
return $request;
});
}
private function getSigningMiddleware()
{
$region = $this->getConnection()->hasParam('aws_region') ? $this->getConnection()->getParam('aws_region') : getenv('AWS_REGION');
$signer = new SignatureV4('es', $region);
$credProvider = $this->getCredentialProvider();
return Middleware::mapRequest(function (RequestInterface $req) use($signer, $credProvider) {
return $signer->signRequest($req, $credProvider()->wait());
});
}
/**
* @return callable
*/
public function getCallable()
{
return Middleware::mapRequest(function (RequestInterface $request) {
if ($request->hasHeader('X-Yves-Host')) {
$requestId = new RequestId();
$request = $request->withAddedHeader('X-Request-ID', $requestId->getRequestId());
}
return $request;
});
}
public static function create()
{
return Middleware::mapRequest(function (RequestInterface $request) {
if ($request->getUri()->getHost() !== 'api.github.com') {
return $request;
}
$authorization = 'token ' . getenv('GITHUB_TOKEN');
return $request->withHeader('Authorization', $authorization);
});
}
public static function setupBeforeClass()
{
$baseUri = getenv('TEST_BASE_URL');
$handler = HandlerStack::create();
$handler->push(Middleware::mapRequest(function (RequestInterface $request) {
$baseUri = $request->getUri();
$baseUri = $baseUri->withPath('/app_test.php' . $baseUri->getPath());
return $request->withUri($baseUri);
}));
self::$staticClient = new Client(['base_uri' => $baseUri, 'defaults' => ['exceptions' => false], 'handler' => $handler]);
self::bootKernel();
}
/**
* @return \GuzzleHttp\Client
*/
public function getClient()
{
if ($this->_client === null) {
$this->_client = new Client($this->clientOptions);
$handler = $this->_client->getConfig('handler');
$handler->push(Middleware::mapRequest(function ($request) {
$this->_restObject = new RestObject($request);
return $request;
}));
}
return $this->_client;
}
/**
*
* @param \Kazoo\SDK $sdk
*/
public function __construct(SDK $sdk)
{
$this->setSDK($sdk);
$sdk = $this->getSDK();
$options = $sdk->getOptions();
$handler = HandlerStack::create();
$handler->push(Middleware::mapRequest(function (Request $request) {
$sdk = $this->getSDK();
$token = $sdk->getAuthToken()->getToken();
return $request->withHeader('X-Auth-Token', $token);
}));
$handler->push(Middleware::mapResponse(function (GuzzleResponse $guzzleResponse) {
$response = new Response($guzzleResponse);
$code = $response->getStatusCode();
switch ($code) {
case 400:
throw new Validation($response);
case 401:
// invalid creds
throw new Unauthenticated($response);
case 402:
// not enough credit
throw new Billing($response);
case 403:
// forbidden
throw new Unauthorized($response);
case 404:
// not found
throw new NotFound($response);
case 405:
// invalid method
throw new InvalidMethod($response);
case 409:
// conflicting documents
throw new Conflict($response);
case 429:
// too many requests
throw new RateLimit($response);
default:
if ($code >= 400 && $code < 500) {
throw new ApiException($response);
} else {
if ($code > 500) {
throw new HttpException($response);
}
}
}
return $guzzleResponse;
}));
$options['handler'] = $handler;
$this->setClient(new GuzzleClient($options));
}
public function mapRequest()
{
return Middleware::mapRequest(function (RequestInterface $request) {
if ($this->getConfig('auth') == 'bulk') {
$token = $this->getAccessToken();
if ($token !== null) {
$request = $request->withHeader('X-SFDC-Session', $token->getToken());
return $request;
}
}
return $request;
});
}
/**
* HttpClient constructor.
*
* @param string $key
* @param string $secret
* @param array $options
*/
public function __construct($key, $secret, array $options = [])
{
$options = array_merge($this->options, $options);
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(Middleware::mapRequest(function (RequestInterface $request) use($key, $secret, $options) {
$date = new \DateTime('now', new \DateTimeZone('UTC'));
return $request->withHeader('User-Agent', $options['user_agent'])->withHeader('Apikey', $key)->withHeader('Date', $date->format('Y-m-d H:i:s'))->withHeader('Signature', sha1($secret . $date->format('Y-m-d H:i:s')));
}));
$this->options = array_merge($this->options, $options, ['handler' => $stack]);
$this->options['base_uri'] = sprintf($this->options['base_uri'], $this->options['api_version']);
$this->client = new Client($this->options);
}
/**
* @return HandlerStack
*/
protected function getGuzzleHandler()
{
$handler = HandlerStack::create();
$handler->push(Middleware::mapResponse(function (ResponseInterface $response) {
$this->lastResponse = $response;
return $response;
}));
$handler->push(Middleware::mapRequest(function (RequestInterface $request) {
$this->lastRequest = $request;
return $request;
}));
return $handler;
}
protected function request($method, $url, $params = [], $headers = [])
{
$jar = $this->cache->has($this->tabName) ? $this->cache->get($this->tabName) : new CookieJar();
$url = new Uri($url);
$headers = array_merge(['Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8', 'User-Agent' => 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.155 Safari/537.36', 'Host' => $url->getHost(), 'Origin' => $url->getScheme() . "://" . $url->getHost() . "/"], $headers);
$stack = HandlerStack::create();
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
$URI = $request->getUri();
$this->baseUri = $URI->__toString();
return $request->withUri($URI);
}));
$client = new Client(["cookies" => $jar, 'handler' => $stack, 'verify' => __DIR__ . '/../cacert.pem']);
$request = new GuzzleHttpRequest($method, $url, $headers, http_build_query($params));
$this->response = $client->send($request, ['timeout' => 120]);
$this->cache->put($this->tabName, $jar, 24 * 60);
}
private function register()
{
$this->container->add('WpsClient', function () {
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
//print_r((string)$request->getUri() . PHP_EOL);
return $request;
}));
return WpsClient::factory(['handler' => $stack, 'base_uri' => $this->config['base_uri'], 'auth' => $this->config['auth'], 'headers' => ['Content-Type' => 'application/json']]);
});
$this->container->add('RequestBuilder', function ($args) {
$client = $this->container->get('WpsClient');
$uriGenerator = new UriGenerator();
return new RequestBuilder($client, $uriGenerator, $args);
});
}
/**
* @inheritdoc
* @SuppressWarnings(PHPMD.StaticAccess)
*/
public function attachMiddleware(HandlerStack $stack)
{
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
$this->onRequestBeforeSend($request);
return $request;
}));
$stack->push(function (callable $handler) {
return function (RequestInterface $request, array $options) use($handler) {
$promise = $handler($request, $options);
return $promise->then(function (ResponseInterface $response) use($request) {
$this->onRequestComplete($request, $response);
return $response;
});
};
});
return $stack;
}
/**
* @param string $apiKey
* @param string $secret
* @param string $url
* @param ClientInterface|null $client
* @param BucketManager $bucketManager
* @param FileManager $fileManager
* @param array $connectionConfig
*/
public function __construct($apiKey, $secret, $url = 'https://myracloud-upload.local/v2/', ClientInterface $client = null, BucketManager $bucketManager = null, FileManager $fileManager = null, array $connectionConfig = [])
{
$this->apiKey = $apiKey;
$this->secret = $secret;
$this->url = $url;
if ($client === null) {
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(Middleware::prepareBody());
$stack->push(Middleware::mapRequest(function (RequestInterface $request) use($secret, $apiKey) {
return $request->withHeader('Authorization', "MYRA {$apiKey}:" . new Authentication\Signature($request->getMethod(), $request->getRequestTarget(), $secret, $request->getHeaders(), $request->getBody()));
}));
$client = new Client(array_merge(['base_uri' => $this->url, 'handler' => $stack], $connectionConfig));
}
$this->client = $client;
$this->bucketManager = $bucketManager ?: new BucketManager($this->client);
$this->fileManager = $fileManager ?: new FileManager($this->client);
}
public static function setUpBeforeClass()
{
$handler = HandlerStack::create();
$handler->push(Middleware::history(self::$history));
$handler->push(Middleware::mapRequest(function (RequestInterface $request) {
$path = $request->getUri()->getPath();
if (strpos($path, '/app_test.php') !== 0) {
$path = '/app_test.php' . $path;
}
$uri = $request->getUri()->withPath($path);
return $request->withUri($uri);
}));
$baseUrl = getenv('TEST_BASE_URL');
if (!$baseUrl) {
static::fail('No TEST_BASE_URL environmental variable set in phpunit.xml.');
}
self::$staticClient = new Client(['base_uri' => $baseUrl, 'http_errors' => false, 'handler' => $handler]);
self::bootKernel();
}
/**
* Push function to middleware handler
*
* @param HandlerStack $stack
*
* @return HandlerStack
*/
public function push(HandlerStack $stack)
{
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
$this->initEvent($request);
return $request;
}), 'eventDispatcher_initEvent');
$stack->push(function (callable $handler) {
return function (RequestInterface $request, array $options) use($handler) {
$promise = $handler($request, $options);
return $promise->then(function (ResponseInterface $response) use($request) {
$this->sendEvent($request, $response);
return $response;
}, function (\Exception $reason) use($request) {
$this->sendErrorEvent($request, $reason);
throw $reason;
});
};
}, 'eventDispatcher_dispatch');
return $stack;
}
/**
* @param Config $config
* @param \GuzzleHttp\Client $client
* @param AbstractDriver $cacheDriver
* @throws ClientException
*/
function __construct(Config $config, \GuzzleHttp\Client $client = null, AbstractDriver $cacheDriver = null, LoggerInterface $logger = null)
{
$this->cfg = $config;
if (!$client) {
$stack = \GuzzleHttp\HandlerStack::create();
$this->effectiveUrlMiddleware = $urlmiddleware = new EffectiveUrlMiddleware();
$stack->push(\GuzzleHttp\Middleware::mapRequest($urlmiddleware));
$client = new \GuzzleHttp\Client(['handler' => $stack, \GuzzleHttp\RequestOptions::ALLOW_REDIRECTS => true]);
}
$this->guzzle = $client;
if ($config['cache']['enabled']) {
if (!$cacheDriver) {
if (!$config['cache']['default_driver']['enabled']) {
throw new ClientException(ClientException::CODE_CACHE_NO_DRIVER);
}
if (!is_writable($config['cache']['default_driver']['path'])) {
throw new ClientException(ClientException::CODE_CACHE_PATH_NOT_WRITABLE, 0, [$config['cache']['default_driver']['path']]);
}
$cacheDriver = new FileSystem(['path' => $config['cache']['default_driver']['path'] . '/storee-client']);
}
$this->cachepool = new Pool($cacheDriver);
}
if ($config['logs']['enabled'] && !$logger) {
if (!$config['logs']['default_driver']['enabled']) {
throw new ClientException(ClientException::CODE_LOGGER_NO_DRIVER);
}
if (!class_exists('\\Monolog\\Logger')) {
throw new ClientException(ClientException::CODE_LOGGER_NO_MONOLOG);
}
if (!is_writable($config['logs']['default_driver']['path'])) {
throw new ClientException(ClientException::CODE_LOGGER_PATH_NOT_WRITABLE, 0, [$config['logs']['default_driver']['path']]);
}
$logger = new \Monolog\Logger('storee');
$logger->pushHandler(new \Monolog\Handler\RotatingFileHandler($config['logs']['default_driver']['path'] . '/storee-client.log', 5, LogLevel::INFO));
$logger->pushHandler(new \Monolog\Handler\RotatingFileHandler($config['logs']['default_driver']['path'] . '/storee-client.err', 5, LogLevel::ERROR));
if ($config['logs']['default_driver']['mail']['enabled']) {
$logger->pushHandler(new \Monolog\Handler\NativeMailerHandler($config['logs']['default_driver']['mail']['to'], $config['logs']['default_driver']['mail']['subject'], $config['logs']['default_driver']['mail']['from'], LogLevel::ERROR));
}
}
$this->logger = $logger ?: new NullLogger();
}
/**
* @return Client
*/
protected function connect()
{
$base_uri = $this->config->get('base_uri');
if ($this->config->has('transport') && $this->config->has('host') && $this->config->has('port')) {
$base_uri = sprintf('%s://%s:%s', $this->config->get('transport'), $this->config->get('host'), $this->config->get('port'));
}
$client_options = ['base_uri' => $base_uri];
if ($this->config->get('debug', false)) {
$client_options['debug'] = true;
}
if ($this->config->has('auth')) {
$auth = (array) $this->config->get('auth');
if (!isset($auth['username'])) {
throw new RuntimeError('Missing required "username" setting within given auth config.');
}
if (!isset($auth['password'])) {
throw new RuntimeError('Missing required "password" setting within given auth config.');
}
$client_options['auth'] = [$auth['username'], $auth['password'], isset($auth['type']) ? $auth['type'] : 'basic'];
}
if ($this->config->has('default_headers')) {
$client_options['headers'] = (array) $this->config->get('default_headers');
}
if ($this->config->has('default_options')) {
$client_options = array_merge($client_options, (array) $this->config->get('default_options')->toArray());
}
if ($this->config->has('default_query')) {
$handler = HandlerStack::create();
$handler->push(Middleware::mapRequest(function (RequestInterface $request) {
$uri = $request->getUri();
foreach ((array) $this->config->get('default_query')->toArray() as $param => $value) {
$uri = Uri::withQueryValue($uri, $param, $value);
}
return $request->withUri($uri);
}));
$client_options['handler'] = $handler;
}
return new Client($client_options);
}
/**
* Set the middleware handlers for all requests using Oauth2
*
* @return HandlerStack|null
*/
protected function returnHandlers()
{
// Create a handler stack that has all of the default middlewares attached
$handler = HandlerStack::create();
//Add the Authorization header to requests.
$handler->push(Middleware::mapRequest(function (RequestInterface $request) {
if ($this->getConfig('auth') == 'oauth2') {
$token = $this->getAccessToken();
if ($token !== null) {
$request = $request->withHeader('Authorization', 'Bearer ' . $token->getToken());
return $request;
}
}
return $request;
}), 'add_oauth_header');
$handler->before('add_oauth_header', $this->retry_modify_request(function ($retries, RequestInterface $request, ResponseInterface $response = null, $error = null) {
if ($retries > 0) {
return false;
}
if ($response instanceof ResponseInterface) {
if ($response->getStatusCode() == 401) {
return true;
}
}
return false;
}, function (RequestInterface $request, ResponseInterface $response) {
if ($response instanceof ResponseInterface) {
if ($response->getStatusCode() == 401) {
$token = $this->acquireAccessToken();
$this->setAccessToken($token, 'Bearer');
$modify['set_headers']['Authorization'] = 'Bearer ' . $token->getToken();
return Psr7\modify_request($request, $modify);
}
}
return $request;
}));
return $handler;
}
/**
* @depends testClass
*/
public function testOAuthHeader()
{
$token = $this->getMockBuilder(TokenInterface::class)->getMock();
$token->expects($this->once())->method('getAccessToken')->willReturn('abc');
$grantType = $this->getMockBuilder(GrantTypeInterface::class)->getMock();
$grantType->expects($this->once())->method('getToken')->willReturn($token);
$tokenStorage = $this->getMockBuilder(TokenStorageInterface::class)->getMock();
$tokenStorage->expects($this->once())->method('hasAccessToken')->willReturn(false);
$middleWare = new OAuth2Middleware($grantType, $tokenStorage);
$mock = new MockHandler([new Response(200)]);
$handler = HandlerStack::create($mock);
$handler->push(Middleware::mapRequest($middleWare));
$container = [];
$history = Middleware::history($container);
$handler->push($history);
$client = new Client(['handler' => $handler]);
$client->get('/');
$this->assertCount(1, $container);
/** @var RequestInterface $request */
$request = $container[0]['request'];
$this->assertTrue($request->hasHeader('Authorization'));
$this->assertEquals('Bearer abc', $request->getHeader('Authorization')[0]);
}
/**
* @return HandlerStack
*/
protected function buildGuzzleStack()
{
// New stack
$stack = new HandlerStack();
// Set handler for the stack, let Guzzle choose
$stack->setHandler(\GuzzleHttp\choose_handler());
// Add Request middleware to the stack that logs the url
$stack->push(Middleware::mapRequest($this->buildMiddlewareLogRequestUrl()));
// Return
return $stack;
}
/**
* Creates a HandlerStack based off of the supplied configuration.
*
* @param string $handlerClass full class name to use for the HTTP handler implementation
* @return HandlerStack configured HandlerStack implementation
*/
protected function buildHandlerStack($handlerClass)
{
$stack = new HandlerStack();
$stack->setHandler(new $handlerClass());
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
$timestamp = gmdate('r');
$authorization = $this->getAuthorization($timestamp);
$requestInterface = $request->withHeader('Date', $timestamp)->withHeader('x-request-id', (string) Uuid::uuid4());
if (!$this->noAuth) {
$requestInterface = $requestInterface->withHeader('Authorization', $authorization);
}
return $requestInterface;
}));
$decider = function ($retries, Request $request, Response $response = null, RequestException $exception = null) {
// Stop retrying if we have exceeded our max
if ($retries > $this->retries) {
return false;
}
// Retry connection exceptions
if ($exception instanceof ConnectException) {
return true;
}
if ($response) {
// Retry on server errors
if ($response->getStatusCode() >= 500) {
return true;
}
}
return false;
};
if ($this->retries > 0) {
$stack->push(Middleware::retry($decider));
}
return $stack;
}
protected function createHandler()
{
$stack = HandlerStack::create();
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
$config = $this->config;
return $request->withHeader('Stripe-Version', $config->getApiVersion())->withHeader('Idempotency-Key', $config->getIdempotencyKey())->withHeader('User-Agent', 'Cartalyst-Stripe/' . $config->getVersion())->withHeader('Authorization', 'Basic ' . base64_encode($config->getApiKey()));
}));
return $stack;
}
public function testMapsRequest()
{
$h = new MockHandler([function (RequestInterface $request, array $options) {
$this->assertEquals('foo', $request->getHeaderLine('Bar'));
return new Response(200);
}]);
$stack = new HandlerStack($h);
$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
return $request->withHeader('Bar', 'foo');
}));
$comp = $stack->resolve();
$p = $comp(new Request('PUT', 'http://www.google.com'), []);
$this->assertInstanceOf(PromiseInterface::class, $p);
}
public function sayHelloBeforeTheRequest()
{
parent::$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
print 'Hello' . PHP_EOL;
return $request;
}));
}
