public function __construct()
{
static::init();
$Stack = new HandlerStack();
$Stack->setHandler(new CurlHandler());
/**
* Здесь ставим ловушку, чтобы с помощью редиректов
* определить адрес сервера, который сможет отсылать сообщения
*/
$Stack->push(Middleware::mapResponse(function (ResponseInterface $Response) {
$code = $Response->getStatusCode();
if ($code >= 301 && $code <= 303 || $code == 307 || $code == 308) {
$location = $Response->getHeader('Location');
preg_match('/https?://([^-]*-)client-s/', $location, $matches);
if (array_key_exists(1, $matches)) {
$this->cloud = $matches[1];
}
}
return $Response;
}));
/**
* Ловушка для отлова хедера Set-RegistrationToken
* Тоже нужен для отправки сообщений
*/
$Stack->push(Middleware::mapResponse(function (ResponseInterface $Response) {
$header = $Response->getHeader("Set-RegistrationToken");
if (count($header) > 0) {
$this->regToken = trim(explode(';', $header[0])[0]);
}
return $Response;
}));
//$cookieJar = new FileCookieJar('cookie.txt', true);
$this->client = new Client(['handler' => $Stack, 'cookies' => true]);
}
private function performTestRequest($logger, $request, $response)
{
$stack = new HandlerStack(new MockHandler([$response]));
$stack->push(LoggingMiddleware::forLogger($logger));
$handler = $stack->resolve();
return $handler($request, [])->wait();
}
/**
* Create the Stack and set a default handler
*/
public function __construct()
{
if (!self::$stack) {
self::$stack = HandlerStack::create();
self::$stack->setHandler(\GuzzleHttp\choose_handler());
}
}
public static function withDoctrineCache(Cache $doctrineCache)
{
$stack = new HandlerStack(new CurlMultiHandler());
$stack->push(new CacheMiddleware(new PublicCacheStrategy(new DoctrineCacheStorage($doctrineCache))), 'cache');
$client = new Client(['handler' => $stack]);
return new self($client);
}
/**
* Configures the stack using services tagged as http_client_middleware.
*
* @param \GuzzleHttp\HandlerStack $handler_stack
* The handler stack
*/
public function configure(HandlerStack $handler_stack)
{
$this->initializeMiddlewares();
foreach ($this->middlewares as $middleware_id => $middleware) {
$handler_stack->push($middleware, $middleware_id);
}
}
/**
* @dataProvider requestList
*/
public function testQueueLimitsNumberOfProcessingRequests(array $queueData, $expectedDuration, $throttleLimit, $threshold = 0.05)
{
$handler = new HandlerStack(new LoopHandler());
$handler->push(ThrottleMiddleware::create());
$client = new \GuzzleHttp\Client(['handler' => $handler, 'base_uri' => Server::$url, 'timeout' => 10]);
$queueEnd = $promises = $responses = $expectedStart = [];
Server::start();
Server::enqueue(array_fill(0, count($queueData), new Response()));
foreach ($queueData as $queueItem) {
list($queueId, $requestDuration, $expectedStartTime) = $queueItem;
$options = [RequestOptions::HTTP_ERRORS => false, RequestOptions::HEADERS => ['duration' => $requestDuration], 'throttle_id' => $queueId, 'throttle_limit' => $throttleLimit];
$expectedStart[$queueId] = $expectedStartTime;
$promises[] = $client->getAsync('', $options)->then(function () use($queueId, &$queueStart, &$queueEnd) {
if (!isset($queueStart[$queueId])) {
$queueStart[$queueId] = microtime(true);
}
$queueEnd[$queueId] = microtime(true);
});
}
$start = microtime(true);
$GLOBALS['s'] = microtime(1);
\GuzzleHttp\Promise\all($promises)->wait();
$duration = microtime(true) - $start;
$this->assertGreaterThan($expectedDuration - $threshold, $duration);
$this->assertLessThan($expectedDuration + $threshold, $duration);
foreach ($queueEnd as $i => $endedAt) {
$duration = $endedAt - $start;
// $this->assertGreaterThan($expectedDuration - $threshold, $endedAt - $start, "Queue #$i started too soon");
// $this->assertLessThan($queueInfo->getExpectedDuration() + $threshold, $queueInfo->getDuration(), "Queue #$i started too late");
//
// $this->assertGreaterThan($started + $queueInfo->getExpectedDelay() - $threshold, $queueInfo->getStartedAt(), "Queue #$i popped too early");
// $this->assertLessThan($started + $queueInfo->getExpectedDelay() + $threshold, $queueInfo->getStartedAt(), "Queue #$i popped too late");
}
}
/**
* Build the guzzle client instance.
*
* @param array $config Additional configuration
*
* @return GuzzleClient
*/
private static function buildClient(array $config = [])
{
$handlerStack = new HandlerStack(\GuzzleHttp\choose_handler());
$handlerStack->push(Middleware::prepareBody(), 'prepare_body');
$config = array_merge(['handler' => $handlerStack], $config);
return new GuzzleClient($config);
}
/**
* @param ClientInterface|null $client
*/
public function __construct(ClientInterface $client = null)
{
if (!$client) {
$handlerStack = new HandlerStack(\GuzzleHttp\choose_handler());
$handlerStack->push(Middleware::prepareBody(), 'prepare_body');
$client = new Client(['handler' => $handlerStack]);
}
$this->client = $client;
}
/**
* @expectedException \GuzzleTor\TorNewIdentityException
*/
public function testExceptionWhileNewIdentity()
{
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(Middleware::tor('127.0.0.1:9050', 'not-existed-host:9051'));
$client = new Client(['handler' => $stack]);
// Throw TorNewIdentityException because of wrong tor control host
$client->get('https://check.torproject.org/', ['tor_new_identity' => true, 'tor_new_identity_exception' => true]);
}
public function setUp()
{
$this->context = new Context(['keys' => ['pda' => 'secret'], 'algorithm' => 'hmac-sha256', 'headers' => ['(request-target)', 'date']]);
$stack = new HandlerStack();
$stack->setHandler(new MockHandler([new Response(200, ['Content-Length' => 0])]));
$stack->push(GuzzleHttpSignatures::middlewareFromContext($this->context));
$stack->push(Middleware::history($this->history));
$this->client = new Client(['handler' => $stack]);
}
public function testAddLogger()
{
$logger = new Logger('Logger');
$messageFormatter = new MessageFormatter();
$logLevel = LogLevel::ALERT;
$middlewareCallback = function () {
};
$this->httpMock->expects($this->once())->method('createMiddlewareLogCallback')->with($logger, $messageFormatter, $logLevel)->willReturn($middlewareCallback);
$this->handlerStackMock->expects($this->once())->method('push')->with($middlewareCallback, 'logger');
$this->httpMock->addLogger($logger, $messageFormatter, $logLevel);
}
/**
* 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($bucket, $pub_key, $sec_key, $suffix = '.ufile.ucloud.cn', $https = false, $debug = false)
{
$this->bucket = $bucket;
$this->pub_key = $pub_key;
$this->sec_key = $sec_key;
$this->host = ($https ? 'https://' : 'http://') . $bucket . $suffix;
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(static::auth($bucket, $pub_key, $sec_key));
$this->httpClient = new Client(['base_uri' => $this->host, 'handler' => $stack, 'debug' => $debug]);
}
/**
* 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);
}
function get_tor_ip()
{
$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(Middleware::tor());
$client = new Client(['handler' => $stack]);
$response = $client->get('https://check.torproject.org/');
if (preg_match('/<strong>([\\d.]+)<\\/strong>/', $response->getBody(), $matches)) {
return $matches[1];
} else {
return null;
}
}
public function testSubscriberDoesNotDoAnythingForNonGigyaAuthRequests()
{
$handler = new MockHandler([function (RequestInterface $request) {
$query = $request->getUri()->getQuery();
$this->assertNotRegExp('/client_id=/', $query);
$this->assertNotRegExp('/client_secret=/', $query);
return new Response(200);
}]);
$stack = new HandlerStack($handler);
$stack->push(CredentialsAuthMiddleware::middleware('key', 'secret', 'user'));
$comp = $stack->resolve();
$promise = $comp(new Request('GET', 'https://example.com'), ['auth' => 'oauth']);
$this->assertInstanceOf(PromiseInterface::class, $promise);
}
/**
* @dataProvider expectProvider
*
* @param int $duration The expected duration.
*/
public function testNullStopwatch($duration)
{
// HandlerStack
$response = new Response(200);
$stack = new HandlerStack(new MockHandler([$response]));
// Middleware
$middleware = new StopwatchMiddleware();
$stack->push($middleware);
$handler = $stack->resolve();
// Request
$request = new Request('GET', 'http://example.com');
$promise = $handler($request, []);
$response = $promise->wait();
$this->assertNotEquals($response->getHeaderLine('X-Duration'), $duration);
}
public function testSend()
{
$self = $this;
$mockRequestData = ['foo' => 'bar', 'token' => self::TOKEN];
$mockResponseData = ['ok' => true, 'foo' => 'bar'];
$handler = HandlerStack::create(new MockHandler([new Response(200, [], json_encode($mockResponseData))]));
$historyContainer = [];
$history = Middleware::history($historyContainer);
$handler->push($history);
$apiClient = new ApiClient(self::TOKEN, new Client(['handler' => $handler]));
$apiClient->addRequestListener(function (RequestEvent $event) use(&$eventsDispatched, $mockRequestData, $self) {
$eventsDispatched[ApiClient::EVENT_REQUEST] = true;
$self->assertEquals($mockRequestData, $event->getRawPayload());
});
$apiClient->addResponseListener(function (ResponseEvent $event) use(&$eventsDispatched, $mockResponseData, $self) {
$eventsDispatched[ApiClient::EVENT_RESPONSE] = true;
$self->assertEquals($mockResponseData, $event->getRawPayloadResponse());
});
$mockPayload = new MockPayload();
$mockPayload->setFoo('bar');
$apiClient->send($mockPayload);
$transaction = $historyContainer[0];
$requestUrl = (string) $transaction['request']->getUri();
$requestContentType = $transaction['request']->getHeader('content-type')[0];
parse_str($transaction['request']->getBody(), $requestBody);
$responseBody = json_decode($transaction['response']->getBody(), true);
$this->assertEquals(ApiClient::API_BASE_URL . 'mock', $requestUrl);
$this->assertEquals('application/x-www-form-urlencoded', $requestContentType);
$this->assertEquals($mockRequestData, $requestBody);
$this->assertEquals($mockResponseData, $responseBody);
$this->assertArrayHasKey(ApiClient::EVENT_REQUEST, $eventsDispatched);
$this->assertArrayHasKey(ApiClient::EVENT_RESPONSE, $eventsDispatched);
}
public function __construct($authKeys = array())
{
$opts = array("headers" => array("User-Agent" => "twitter-wrapi"), "query" => array("stringify_ids" => "true"), 'auth' => 'oauth');
$handler = HandlerStack::create();
$handler->push(new Oauth1($authKeys));
function build(&$obj, $prefix, $apiList)
{
$path = $prefix;
if ($prefix !== '') {
$path .= '/';
}
foreach ($apiList as $name) {
$json = file_get_contents(__DIR__ . '/api/' . $path . $name . '.json');
$endpoint = json_decode($json, true);
$pre = $prefix === '' ? $name : $prefix . '.' . $name;
foreach ($endpoint as $sub => $ep) {
$obj[$pre . '.' . $sub] = $ep;
}
}
}
$all = [];
build($all, '', ['statuses', 'media', 'direct_messages', 'search', 'friendships', 'friends', 'followers', 'account', 'blocks', 'users', 'favorites', 'lists', 'saved_searches', 'geo', 'trends', 'application', 'help']);
build($all, 'users', ['suggestions']);
build($all, 'lists', ['members', 'subscribers']);
parent::__construct('https://api.twitter.com/1.1/', $all, $opts, ['handler' => $handler]);
}
private function getMockClient(array $response)
{
$mock = new MockHandler($response);
$handler = HandlerStack::create($mock);
$client = new Client(['handler' => $handler]);
return $client;
}
/**
* @return GuzzleClient
*/
public function buildHttpMockClient($body)
{
// Create a mock and queue two responses.
$mock = new MockHandler([new Response(200, array(), $body), new Response(200, array(), $body), new Response(400, array(), 'fault{'), new Response(400, array(), $body), new Response(400, array(), $body)]);
$handler = HandlerStack::create($mock);
return new GuzzleClient(['handler' => $handler]);
}
/**
*
* @return Client
*/
protected function getClient(array $responseQueue = [])
{
$mock = new MockHandler($responseQueue);
$handler = HandlerStack::create($mock);
$client = new Client(['handler' => $handler]);
return $client;
}
private function apiWithResponse($status, $header, $body)
{
$responses = [new Response($status, $header, $body)];
$this->mockHandler = new MockHandler($responses);
$client = new Client(['handler' => HandlerStack::create($this->mockHandler)]);
return new API('en', '', $client);
}
/**
* TestClient constructor.
*
* @param MockHandler $mock
* @param IdGeneratorInterface $idGenerator
*/
public function __construct(MockHandler $mock, IdGeneratorInterface $idGenerator)
{
$handler = HandlerStack::create($mock);
$this->idGenerator = $idGenerator;
$guzzle = new Client(['handler' => $handler]);
$this->client = new JsonRpcClient($guzzle, new Uri('http://localhost/'), $this->idGenerator);
}
public function sync(array $subscriptions)
{
$synched = $failed = 0;
if (!empty($subscriptions)) {
$stack = HandlerStack::create();
$middleware = new Oauth1(['consumer_key' => $this->consumerKey, 'consumer_secret' => $this->consumerSecret, 'token' => '', 'token_secret' => '']);
$stack->push($middleware);
$client = new GuzzleClient(['base_uri' => 'https://restapi.mailplus.nl', 'handler' => $stack, 'auth' => 'oauth', 'headers' => ['Accept' => 'application/json', 'Content-Type' => 'application/json']]);
foreach ($subscriptions as $subscription) {
try {
$contact = ['update' => true, 'purge' => false, 'contact' => ['externalId' => $subscription->getId(), 'properties' => ['email' => $subscription->getEmail()]]];
$response = $client->post('/integrationservice-1.1.0/contact', ['body' => json_encode($contact)]);
if ($response->getStatusCode() == '204') {
//Contact added successfully status code
$this->subscriptionManager->updateStatus($subscription, Subscription::STATUS_SYNCED);
++$synched;
} else {
$this->subscriptionManager->updateStatus($subscription, Subscription::STATUS_FAILED);
++$failed;
}
} catch (\Exception $e) {
$this->subscriptionManager->updateStatus($subscription, Subscription::STATUS_FAILED);
++$failed;
}
}
}
return sprintf('Synched %d,failed %d subscriptions of %d total', $synched, $failed, count($subscriptions));
}
/**
* Constructs a Solr client from input params.
*
* @return Client
*/
protected function getClient(InputInterface $input, OutputInterface $output)
{
if (isset($this->client)) {
return $this->client;
}
$baseURL = $input->getOption('url');
$username = $input->getOption('username');
$password = $input->getOption('password');
// Add trailing slash if one doesn't exist
if ($baseURL[strlen($baseURL) - 1] !== '/') {
$baseURL .= '/';
}
$output->writeln("Solr URL: <info>{$baseURL}</info>");
if (!empty($username)) {
$output->writeln("Basic auth: <info>{$username}</info>");
}
// Middleware which logs requests
$before = function (Request $request, $options) use($output) {
$url = $request->getUri();
$method = $request->getMethod();
$output->writeln(sprintf("<info>%s</info> %s ", $method, $url));
};
// Setup the default handler stack and add the logging middleware
$stack = HandlerStack::create();
$stack->push(Middleware::tap($before));
// Guzzle options
$options = ['base_uri' => $baseURL, 'handler' => $stack];
if (isset($username)) {
$options['auth'] = [$username, $password];
}
$guzzle = new GuzzleClient($options);
return new Client($guzzle);
}
/**
* 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));
}
});
}
public static function setUpBeforeClass()
{
$mock = new MockHandler([new Response(200, [], file_get_contents(__DIR__ . '/SomeApiResponse.json')), new Response(200, [], file_get_contents(__DIR__ . '/SomeEmptyApiResponse.json')), new Response(200, [], file_get_contents(__DIR__ . '/SomeEmptyApiResponseWithUnsupportedEvents.json'))]);
$handler = HandlerStack::create($mock);
$client = new Client(['handler' => $handler]);
self::$apiEventStore = new GuzzleApiEventStore($client, new SomeSerializer());
}
/**
* @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]);
}
protected function getHttpSettings()
{
$handlers = HandlerStack::create();
$handlers->push(new Oauth1($this->credentials));
$settings = ['defaults' => ['auth' => $this->accessToken ? 'oauth2' : 'oauth', 'handler' => $handlers]];
return array_merge(parent::getHttpSettings(), $settings);
}
