/**
* Register method.
*/
public function register()
{
// Configuring all guzzle clients.
$this->app->bind(ClientInterface::class, function () {
// Guzzle client
return new Client(['handler' => $this->app->make(HandlerStack::class)]);
});
$this->app->alias(ClientInterface::class, Client::class);
// Bind if needed.
$this->app->bindIf(HandlerStack::class, function () {
return HandlerStack::create();
});
// If resolved, by this SP or another, add some layers.
$this->app->resolving(HandlerStack::class, function (HandlerStack $stack) {
/** @var \DebugBar\DebugBar $debugBar */
$debugBar = $this->app->make('debugbar');
$stack->push(new Middleware(new Profiler($timeline = $debugBar->getCollector('time'))));
$stack->unshift(new ExceptionMiddleware($debugBar->getCollector('exceptions')));
/** @var \GuzzleHttp\MessageFormatter $formatter */
$formatter = $this->app->make(MessageFormatter::class);
$stack->unshift(GuzzleMiddleware::log($debugBar->getCollector('messages'), $formatter));
// Also log to the default PSR logger.
if ($this->app->bound(LoggerInterface::class)) {
$logger = $this->app->make(LoggerInterface::class);
// Don't log to the same logger twice.
if ($logger === $debugBar->getCollector('messages')) {
return;
}
// Push the middleware on the stack.
$stack->unshift(GuzzleMiddleware::log($logger, $formatter));
}
});
}
private function initClient()
{
$handlerStack = HandlerStack::create();
$handlerStack->push(MiddlewareBuilder::factoryForPing($this->logger, self::MAX_RETRIES));
$handlerStack->push(Middleware::log($this->logger, new MessageFormatter('{hostname} {req_header_User-Agent} - [{ts}] \\"{method} {resource} {protocol}/{version}\\" {code} {res_header_Content-Length}')));
$this->client = new \GuzzleHttp\Client(['base_uri' => $this->storageApi->getApiUrl(), 'handler' => $handlerStack]);
}
public function __construct($parameters = [], GuzzleHttp\ClientInterface $httpClient = null)
{
$this->configure($parameters);
$stack = GuzzleHttp\HandlerStack::create();
if ($this->logger instanceof LoggerInterface) {
$stack->push(GuzzleHttp\Middleware::log($this->logger, new GuzzleHttp\MessageFormatter(GuzzleHttp\MessageFormatter::DEBUG)));
}
$this->httpClient = new GuzzleHttp\Client(['handler' => $stack]);
}
/**
* Create and configure a http curl client.
*
* @param array $settings additional settings
*
* @return Client
*/
public function create(array $settings = [])
{
$stack = null;
$settings = $this->platform->toArray() + $settings;
if ($this->getLogger() instanceof LoggerInterface) {
$stack = HandlerStack::create();
$stack->push(Middleware::log($this->getLogger(), new MessageFormatter('{request} - {response}')));
}
return new Client(['base_url' => (string) $settings['url'], 'handler' => $stack, 'exceptions' => false, 'timeout' => (double) $settings['responseTimeout'], 'connection_timeout' => (double) $settings['connectionTimeout']]);
}
public function __construct($base = null)
{
if (!$this->client) {
$logger = new Logger('mylogger');
$logger->pushHandler(new StreamHandler(__DIR__ . '/../logs/log.txt'));
$formatter = new MessageFormatter(MessageFormatter::DEBUG);
$handler = HandlerStack::create()->push(Middleware::log($logger, $formatter));
$this->client = new Client(['base_uri' => $base ?: 'https://api.github.com', 'handler' => $handler]);
}
}
/**
* Getter for the HTTP client.
*
* @return Client
*/
protected function getHttpClient()
{
if ($this->client === null) {
if ($this->logger instanceof LoggerInterface) {
$this->handlerStack->push(Middleware::log($this->logger, $this->messageFormatter, $this->logLevel));
}
$this->options['handler'] = $this->handlerStack;
$this->client = new Client($this->options);
}
return $this->client;
}
public function __construct($debug, LoggerInterface $httpLogAdapter)
{
$this->debug = $debug;
$this->httpLogAdapter = $httpLogAdapter;
$config = [];
if ($this->debug) {
$config['handler'] = HandlerStack::create();
$config['handler']->push(Middleware::log($this->httpLogAdapter, new MessageFormatter(MessageFormatter::DEBUG)));
}
parent::__construct($config);
}
protected function getHttpClient()
{
if (!is_null($this->httpClient)) {
return $this->httpClient;
}
$stack = GuzzleHttp\HandlerStack::create();
if ($this->logger instanceof LoggerInterface) {
$stack->push(GuzzleHttp\Middleware::log($this->logger, new GuzzleHttp\MessageFormatter(GuzzleHttp\MessageFormatter::DEBUG)));
}
$this->httpClient = new GuzzleHttp\Client(['base_uri' => $this->getUrl(), 'handler' => $stack]);
return $this->httpClient;
}
public static function prepareConfig($config, $logger)
{
if (!isset($config['base_uri']) && isset($config['base_url'])) {
$config['base_uri'] = $config['base_url'];
}
$stack = HandlerStack::create();
if ($logger) {
if ($logger instanceof \Psr\Log\LoggerInterface) {
$stack->push(Middleware::log($logger, new MessageFormatter(MessageFormatter::DEBUG)));
} else {
throw new \Exception('Logger must implement PsrLogLoggerInterface');
}
}
$config['handler'] = $stack;
return $config;
}
public static function create($access_token)
{
$google_api_key = getenv('GOOGLE_API_KEY');
$google_end_point = getenv('GOOGLE_ENDPOINT');
if (!$google_api_key or !$google_end_point) {
throw new \Exception("Google is not configured");
}
$handler = HandlerStack::create();
$handler->push(Middleware::log(new Logger('console'), new MessageFormatter('{method} {uri} {req_headers} {req_body}')));
$google_rest_client = new RESTAdapter\RESTClient($google_end_point, $handler);
$google_maps = new Google\Maps($google_api_key, $google_rest_client);
$instagram_end_point = getenv('INSTAGRAM_ENDPOINT');
if (!$instagram_end_point) {
throw new \Exception('Instagram is not configured');
}
$instagram_rest_client = new RESTAdapter\RESTClient($instagram_end_point, $handler);
$instagram_media_endpoint = new Instagram\MediaEndPoint($access_token, $instagram_rest_client);
return new MediaInspector($instagram_media_endpoint, $google_maps);
}
/**
* @return \Aws\Handler\GuzzleV6\GuzzleHandler
*/
private function getHttpHandler()
{
$guzzleStack = \GuzzleHttp\HandlerStack::create();
$guzzleStack->push(\GuzzleHttp\Middleware::retry(function ($retries, \GuzzleHttp\Psr7\Request $request, \GuzzleHttp\Psr7\Response $response = null, \GuzzleHttp\Exception\RequestException $exception = null) {
if ($retries >= 5) {
return false;
}
if ($exception instanceof \GuzzleHttp\Exception\ConnectException) {
return true;
}
if ($response) {
if ($response->getStatusCode() == 400) {
return true;
}
}
return false;
}));
if ($this->output && $this->output->isVeryVerbose()) {
$guzzleStack->push(\GuzzleHttp\Middleware::log(new \Monolog\Logger('main'), new \GuzzleHttp\MessageFormatter('[{code}] {req_body}')));
}
return new \Aws\Handler\GuzzleV6\GuzzleHandler(new \GuzzleHttp\Client(['handler' => $guzzleStack]));
}
/**
* Execute an XML request to Intacct
*
* @param XMLWriter $xml
* @return ResponseInterface
*/
private function execute($xml)
{
//this is used for retry logic
$calls = [];
$decider = function ($retries, $request, $response, $error) use(&$calls) {
$calls[] = func_get_args();
if (count($calls) > $this->maxRetries) {
return false;
}
if ($error instanceof \GuzzleHttp\Exception\ServerException) {
//retry if receiving http 5xx error codes
$response = $error->getResponse();
if (in_array($response->getStatusCode(), $this->noRetryServerErrorCodes) === true) {
return false;
} else {
return true;
}
}
//do not retry otherwise
return false;
};
//setup the handler
if ($this->mockHandler instanceof MockHandler) {
$handler = HandlerStack::create($this->mockHandler);
} else {
$handler = HandlerStack::create();
}
//add the retry logic before the http_errors middleware
$handler->before('http_errors', Middleware::retry($decider), 'retry_logic');
//push the history middleware to the top of the stack
$handler->push(Middleware::history($this->history));
if ($this->logger) {
//push the logger middleware to the top of the stack
$handler->push(Middleware::log($this->logger, $this->logMessageFormat, $this->logLevel));
}
$client = new Client(['handler' => $handler]);
$options = ['body' => $xml->flush(), 'verify' => $this->getVerifySSL(), 'headers' => ['content-type' => self::REQUEST_CONTENT_TYPE, 'User-Agent' => $this->getUserAgent()]];
$response = $client->post($this->endpointURL, $options);
return $response;
}
/**
* Attention: This example script will modify the test library! Do not run this script
* unless you are prepared for that.
*/
require_once __DIR__ . '/../vendor/autoload.php';
use Seafile\Client\Resource\Directory;
use Seafile\Client\Resource\File;
use Seafile\Client\Resource\Library;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use GuzzleHttp\MessageFormatter;
use Monolog\Logger;
use Seafile\Client\Http\Client;
$logger = new Logger('Logger');
$stack = HandlerStack::create();
$stack->push(Middleware::log($logger, new MessageFormatter("{hostname} {req_header_Authorization} - {req_header_User-Agent} - [{date_common_log}] \"{method} {host}{target} HTTP/{version}\" {code} {res_header_Content-Length} req_body: {req_body} response_body: {res_body}")));
/**
* Example:
* {"token": "your_token"}
*/
$tokenFile = getenv("HOME") . "/.seafile-php-sdk/api-token.json";
/**
* Example:
* {
* "baseUri": "https://your.seafile-server.example.com",
* "testLibId": "ID of an encrypted library",
* "testLibPassword": "******"
* }
*/
$cfgFile = getenv("HOME") . "/.seafile-php-sdk/cfg.json";
if (!is_readable($tokenFile)) {
/**
* This method will return an OpenStack service ready fully built and ready for use. There is
* some initial setup that may prohibit users from directly instantiating the service class
* directly - this setup includes the configuration of the HTTP client's base URL, and the
* attachment of an authentication handler.
*
* @param $serviceName The name of the service as it appears in the OpenStack\* namespace
* @param $serviceVersion The major version of the service
* @param array $serviceOptions The service-specific options to use
*
* @return \OpenStack\Common\Service\ServiceInterface
*
* @throws \Exception
*/
public function createService($serviceName, $serviceVersion, array $serviceOptions = [])
{
$options = $this->mergeOptions($serviceOptions);
if (!isset($options['identityService'])) {
$httpClient = $this->httpClient($options['authUrl'], HandlerStack::create());
$options['identityService'] = Service::factory($httpClient);
}
if (!isset($options['authHandler'])) {
$options['authHandler'] = function () use($options) {
return $options['identityService']->generateToken($options);
};
}
if (!isset($options['httpClient']) || !$options['httpClient'] instanceof ClientInterface) {
if (strcasecmp($serviceName, 'identity') === 0) {
$baseUrl = $options['authUrl'];
$stack = $this->getStack($options['authHandler']);
} else {
list($token, $baseUrl) = $options['identityService']->authenticate($options);
$stack = $this->getStack($options['authHandler'], $token);
}
if (!empty($options['debugLog'])) {
$stack->push(GuzzleMiddleware::log($options['logger'], $options['messageFormatter']));
}
$options['httpClient'] = $this->httpClient($baseUrl, $stack);
}
list($apiClass, $serviceClass) = $this->getClasses($serviceName, $serviceVersion);
return new $serviceClass($options['httpClient'], new $apiClass());
}
/**
* @codeCoverageIgnore
*
* @param \Psr\Log\LoggerInterface $logger
* @param \GuzzleHttp\MessageFormatter $messageFormatter
* @param string $logLevel
* @return callable
*/
protected function createMiddlewareLogCallback($logger, $messageFormatter, $logLevel = LogLevel::INFO)
{
return Middleware::log($logger, $messageFormatter, $logLevel);
}
/**
* @codeCoverageIgnore
*/
public static function log(LoggerInterface $logger, MessageFormatter $formatter, $logLevel = LogLevel::INFO) : callable
{
return GuzzleMiddleware::log($logger, $formatter, $logLevel);
}
public function testLogsRequestsAndErrors()
{
$h = new MockHandler([new Response(404)]);
$stack = new HandlerStack($h);
$logger = new Logger();
$formatter = new MessageFormatter('{code} {error}');
$stack->push(Middleware::log($logger, $formatter));
$stack->push(Middleware::httpErrors());
$comp = $stack->resolve();
$p = $comp(new Request('PUT', 'http://www.google.com'), ['http_errors' => true]);
$p->wait(false);
$this->assertContains('PUT http://www.google.com', $logger->output);
$this->assertContains('404 Not Found', $logger->output);
}
private function getLogger($stack)
{
if ($this->logger) {
$loggingmiddleware = Middleware::log($this->logger, new MessageFormatter('{request} - {response}'));
$stack->push($loggingmiddleware);
}
return $stack;
}
protected function loggingClient()
{
$stack = HandlerStack::create(new CurlHandler());
$stack->push(Middleware::log($this->logger(), new MessageFormatter(MessageFormatter::DEBUG)));
return new Client(['handler' => $stack, 'http_errors' => false]);
}
<?php
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\MessageFormatter;
use GuzzleHttp\Middleware;
use Interop\Container\ContainerInterface;
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
use Somoza\OAuth2\Client\Provider\Sign2Pay;
$container = $app->getContainer();
$settings = $container->get('settings');
$options = $settings['oauth2'];
// == application logger
$container['logger'] = function (ContainerInterface $c) {
$settings = $c->get('settings')['logger'];
$logger = new Logger($settings['name']);
$logger->pushProcessor(new \Monolog\Processor\UidProcessor());
$logger->pushHandler(new StreamHandler($settings['path'], Logger::DEBUG));
return $logger;
};
// == Sign2Pay provider
// includes HandlerStack with logging
$stack = HandlerStack::create();
$stack->push(Middleware::log($container->get('logger'), new MessageFormatter(MessageFormatter::DEBUG)));
$client = new HttpClient(['handler' => $stack]);
$collaborators['httpClient'] = $client;
$provider = new Sign2Pay($options, $collaborators);
$container['oauth'] = $provider;
/**
* Get Handler Stack
* @return HandlerStack
*/
public function getStack()
{
$stack = HandlerStack::create();
$stack->push(Middleware::log($this->apiLogger, new MessageFormatter('[GUZZLE LOG] ' . $this->infosLogs)));
return $stack;
}
/**
* Get the API token from the server.
*
* @param string $user Username/Email
* @param string $password Password
* @return bool|string
*/
public function getAPIToken($user, $password)
{
$logger = new Logger('Logger');
$stack = HandlerStack::create();
$stack->push(Middleware::log($logger, new MessageFormatter("{hostname} {req_header_Authorization} - {req_header_User-Agent} - [{date_common_log}] \"{method} {host}{target} HTTP/{version}\" {code} {res_header_Content-Length} req_body: {req_body} response_body: {res_body}")));
$client = new \GuzzleHttp\Client(['debug' => false, 'handler' => $stack]);
$tokenaddress = rtrim($this->server, "/") . "/api2/auth-token/";
$authstring = "username="******"&password="******"Sending auth request: " . $tokenaddress);
$response = false;
try {
$response = $client->request('POST', $tokenaddress, array('body' => $authstring, 'headers' => array('Content-Type' => 'application/x-www-form-urlencoded')));
} catch (ClientException $e) {
$response = $e->getResponse();
error_log(print_r($response, true));
error_log(print_r($response->getBody(), true));
error_log("C E: " . self::parseErrorCode($response->getStatusCode()));
} catch (ServerException $e) {
$response = $e->getResponse();
error_log(print_r($response, true));
error_log(print_r($response->getBody(), true));
error_log("S E: " . self::parseErrorCode($response->getStatusCode()));
} catch (BadResponseException $e) {
$response = $e->getResponse();
error_log(print_r($response, true));
error_log(print_r($response->getBody(), true));
error_log("BR E: " . self::parseErrorCode($response->getStatusCode()));
} catch (\Exception $e) {
error_log($e->getMessage());
}
if (!$response || $response->getStatusCode() != 200) {
return false;
}
$token = json_decode($response->getBody());
$this->token = (string) $token->token;
return $this->token;
}
/**
* @param $log_file
* @param array $guzzle_options
*
* @return Client
* @throws \Exception
*/
protected function createLoggable($log_file, array $guzzle_options = [])
{
$writer = new \Monolog\Handler\StreamHandler($log_file);
$writer->setFormatter(new \Monolog\Formatter\LineFormatter(null, null, true));
$logger = new \Monolog\Logger('korchasa\\Telegram');
$logger->pushHandler($writer);
$handler = \GuzzleHttp\HandlerStack::create();
$handler->push(\GuzzleHttp\Middleware::log($logger, new \GuzzleHttp\MessageFormatter(\GuzzleHttp\MessageFormatter::DEBUG)));
return new Client(array_merge(array('handler' => $handler, 'http_errors' => false), $guzzle_options));
}
$instructions = 'Take ' . $step['html_instructions'];
} elseif (stripos($type, 'BUS') !== false) {
$short_name = isset($step['transit_details']['line']['short_name']) && 1 == 2 ? ' (#' . $step['transit_details']['line']['short_name'] . ')' : '';
$instructions = 'Take ' . $step['html_instructions'] . $short_name;
}
}
}
$descr[] = $instructions;
//. ' for ' . $step['duration']['text'];
}
}
return $descr;
}
$logger = new Monolog\Logger('directions');
$logger->pushHandler(new \Monolog\Handler\StreamHandler('php://stdout'));
$stack = HandlerStack::create();
$stack->push(Middleware::log($logger, new MessageFormatter(MessageFormatter::CLF)));
$client = new GuzzleHttp\Client(['handler' => $stack, 'base_uri' => 'https://maps.googleapis.com']);
$origin = 'Ben Gurion Airport, 7015001';
$destination = 'Dan Tel Aviv Hotel, Ha-Yarkon Street 99, Tel Aviv-Yafo';
$response = $client->get('/maps/api/directions/json', ['query' => ['origin' => $origin, 'destination' => $destination, 'mode' => 'transit', 'key' => 'AIzaSyDUDSK5jDoVKT2NdrE2FOKs4gbyjYzakZA', 'language' => 'en']]);
$decoded = json_decode($response->getBody(), true);
$directions = [];
foreach ($decoded['routes'] as $route) {
$directions[] = createDirections($route);
}
echo "\n\n";
for ($i = 0; $i < count($directions); $i++) {
echo "Direction #" . ($i + 1), "\n";
echo implode('. ', $directions[$i]), "\n\n";
}
/**
* @codeCoverageIgnore
*/
private function addDebugMiddleware(array $options, HandlerStack &$stack)
{
if (!empty($options['debugLog']) && !empty($options['logger']) && !empty($options['messageFormatter'])) {
$stack->push(GuzzleMiddleware::log($options['logger'], $options['messageFormatter']));
}
}
protected function initClient()
{
$handlerStack = HandlerStack::create();
/** @noinspection PhpUnusedParameterInspection */
$handlerStack->push(Middleware::retry(function ($retries, RequestInterface $request, ResponseInterface $response = null, $error = null) {
return $response && $response->getStatusCode() == 503;
}, function ($retries) {
return rand(60, 600) * 1000;
}));
/** @noinspection PhpUnusedParameterInspection */
$handlerStack->push(Middleware::retry(function ($retries, RequestInterface $request, ResponseInterface $response = null, $error = null) {
if ($retries >= self::RETRIES_COUNT) {
return false;
} elseif ($response && $response->getStatusCode() > 499) {
return true;
} elseif ($error) {
return true;
} else {
return false;
}
}, function ($retries) {
return (int) pow(2, $retries - 1) * 1000;
}));
$handlerStack->push(Middleware::cookies());
if ($this->logger) {
$handlerStack->push(Middleware::log($this->logger, $this->loggerFormatter));
}
$this->guzzle = new \GuzzleHttp\Client(array_merge(['handler' => $handlerStack, 'cookies' => true], $this->guzzleOptions));
}
private function createHttpClient()
{
$stack = HandlerStack::create();
$format = MessageFormatter::CLF . "\n\n<<<<<<<<\n{response}\n--------\n{error}";
$stack->push(Middleware::log($this->get('logger'), new MessageFormatter($format)));
return new Client(['handler' => $stack]);
}
/**
* @param $token
* @param $runId
* @param $userAgent
* @param $maxRetries
* @param array $config
* @param callable|null $delay
* @return GuzzleClient
*/
protected function initClient($token, $runId, $userAgent, $maxRetries, array $config = [], callable $delay = null)
{
// Initialize handlers (start with those supplied in constructor)
if (isset($config['handler']) && $config['handler'] instanceof HandlerStack) {
$handlerStack = HandlerStack::create($config['handler']);
} else {
$handlerStack = HandlerStack::create();
}
// Set exponential backoff for cases where job detail returns error
$handlerStack->push(Middleware::retry(self::createDefaultDecider($maxRetries), $delay));
// Set handler to set default headers
$handlerStack->push(Middleware::mapRequest(function (RequestInterface $request) use($token, $runId, $userAgent) {
$req = $request->withHeader('User-Agent', $userAgent);
if ($token) {
$req = $req->withHeader('X-StorageApi-Token', $token);
}
if (!$req->hasHeader('content-type')) {
$req = $req->withHeader('Content-type', 'application/json');
}
if ($runId) {
$req = $req->withHeader('X-KBC-RunId', $runId);
}
return $req;
}));
// Set client logger
if (isset($config['logger']) && $config['logger'] instanceof LoggerInterface) {
$handlerStack->push(Middleware::log($config['logger'], new MessageFormatter("{hostname} {req_header_User-Agent} - [{ts}] \"{method} {resource} {protocol}/{version}\" " . "{code} {res_header_Content-Length}")));
}
// finally create the instance
return new GuzzleClient(['base_url' => $this->url, 'handler' => $handlerStack]);
}
