/**
* {@inheritdoc}
*/
protected function read($length = null)
{
if (is_null($length)) {
return trim(Utils::readLine($this->inputStream));
}
return $this->inputStream->read($length);
}
/**
* Create color profile object from filename.
*
* @param string $filename
*
* @throws RuntimeException
*
* @return $this
*/
public static function fromFilename($filename)
{
if (!file_exists($filename) || !is_file($filename) || !is_readable($filename)) {
throw new RuntimeException(sprintf('Filename %s is an invalid profile file or is not readable', $filename));
}
return new static(StreamUtils::create(StreamUtils::open($filename, 'r')));
}
public function writeContainerLogs(Container $container)
{
$stream = $this->restClient->get(sprintf('/containers/%s/logs?stderr=1&stdout=1&follow=1', $container->getId()), ['stream' => true]);
while (!$stream->getBody()->eof()) {
$line = \GuzzleHttp\Stream\Utils::readLine($stream->getBody());
$line = substr($line, 8);
$container->addToLog($line);
}
}
public function __invoke($retries, AbstractTransferEvent $event)
{
if (!($response = $event->getResponse())) {
return RetrySubscriber::DEFER;
}
if (!$response->hasHeader('x-amz-crc32')) {
return RetrySubscriber::DEFER;
}
$hash = hexdec(Utils::hash($response->getBody(), 'crc32b'));
return (int) $response->getHeader('x-amz-crc32') !== $hash ? RetrySubscriber::RETRY : RetrySubscriber::DEFER;
}
public function fetch(RequestInterface $request)
{
$key = $this->getCacheKey($request);
$entry = $this->cache->fetch($key);
if (!$entry) {
return null;
}
$response = new Response($entry['code'], $entry['headers'], Stream\Utils::create($entry['body']));
$request->getConfig()->set('cache.key', $key);
return $response;
}
public function getStatuses($param, $callback)
{
$response = $this->client->post('statuses/filter.json', ['body' => $param]);
$body = $response->getBody();
while (!$body->eof()) {
$line = Utils::readLine($body);
$data = json_decode($line, true);
if (is_null($data)) {
continue;
}
call_user_func($callback, $data);
if (ob_get_level() > 0) {
ob_flush();
}
flush();
}
}
/**
* listen endpoint
*
* @param $channels list of channels
* @param null $callback
*/
public function listen($channels, $callback = null)
{
$endpoint = $this->makeEndpoint($this->listenServerOptions);
if (substr($this->listenServerOptions['path'], -1) != '/') {
$endpoint .= '/';
}
$endpoint .= implode(',', (array) $channels);
$response = $this->client->get($endpoint, ['debug' => $this->debug, 'stream' => true]);
$body = $response->getBody();
while (!$body->eof()) {
if (is_callable($callback)) {
call_user_func($callback, Utils::readline($body));
} else {
echo Utils::readline($body);
}
}
}
/**
* {@inheritdoc}
*/
public function fetch(FeedInterface $feed, StateInterface $state)
{
$response = $this->get($feed->getSource(), $this->getCacheKey($feed));
$feed->setSource($response->getEffectiveUrl());
// 304, nothing to see here.
if ($response->getStatusCode() == 304) {
$state->setMessage($this->t('The feed has not been updated.'));
throw new EmptyFeedException();
}
// Copy the temp stream to a real file.
$download_file = drupal_tempnam('temporary://', 'feeds_http_fetcher');
$dest_stream = Utils::create(fopen($download_file, 'w+'));
Utils::copyToStream($response->getBody(), $dest_stream);
$response->getBody()->close();
$dest_stream->close();
return new HttpFetcherResult($download_file, $response->getHeaders());
}
/**
* Drains the stream into the "save_to" client option.
*
* @param resource $stream
* @param string|resource|StreamInterface $dest
*
* @return Stream
* @throws \RuntimeException when the save_to option is invalid.
*/
private function drain($stream, $dest)
{
if (is_resource($stream)) {
if (!is_resource($dest)) {
$stream = Stream::factory($stream);
} else {
stream_copy_to_stream($stream, $dest);
fclose($stream);
rewind($dest);
return $dest;
}
}
// Stream the response into the destination stream
$dest = is_string($dest) ? new Stream(Utils::open($dest, 'r+')) : Stream::factory($dest);
Utils::copyToStream($stream, $dest);
$dest->seek(0);
$stream->close();
return $dest;
}
public function setMd5(PreparedEvent $event)
{
$client = $event->getClient();
$command = $event->getCommand();
$body = $event->getRequest()->getBody();
// If ContentMD5 is set or there is no body, there is nothing to do.
if ($command['ContentMD5'] || !$body) {
return;
}
// If and MD5 is required or enabled, add one.
$optional = $client->getConfig('calculate_md5') && in_array($command->getName(), self::$canMd5);
if (in_array($command->getName(), self::$requireMd5) || $optional) {
// Throw exception is calculating and MD5 would result in an error.
if (!$body->isSeekable()) {
throw new CouldNotCreateChecksumException('md5');
}
// Set the Content-MD5 header.
$event->getRequest()->setHeader('Content-MD5', base64_encode(Utils::hash($body, 'md5', true)));
}
}
/**
* Drain the stream into the destination stream
*/
private function getSaveToBody(RequestInterface $request, StreamInterface $stream)
{
if ($saveTo = $request->getConfig()['save_to']) {
// Stream the response into the destination stream
$saveTo = is_string($saveTo) ? new Stream(Utils::open($saveTo, 'r+')) : Stream::factory($saveTo);
} else {
// Stream into the default temp stream
$saveTo = Stream::factory();
}
Utils::copyToStream($stream, $saveTo);
$saveTo->seek(0);
$stream->close();
return $saveTo;
}
public function __toString()
{
return Utils::copyToString($this);
}
/**
* Create a cache key for a response's body
*
* @param string $url URL of the entry
* @param StreamInterface $body Response body
*
* @return string
*/
private function getBodyKey($url, StreamInterface $body)
{
return $this->keyPrefix . md5($url) . Stream\Utils::hash($body, 'md5');
}
public function getContents()
{
return Utils::copyToString($this);
}
public function getContents($maxLength = -1)
{
return Utils::copyToString($this, $maxLength);
}
/**
* {@inheritdoc}
*/
public function getColorProfile()
{
try {
$data = $this->gmagick->getimageprofile('ICM');
} catch (\GmagickException $exception) {
return null;
}
return new ColorProfile(StreamUtils::create($data));
}
/**
* This method opens a connection to the Twitter streaming API and applies the given callback function to each Tweet
* @param $track
* @param $callback
*/
public function getStream($track, $callback)
{
$client = $this->createClient(self::TWITTER_STREAM_URL);
$response = $client->post(self::STATUSES_ENDPOINT, ['body' => $track]);
$body = $response->getBody();
while (!$body->eof()) {
//Read a line of the response
$line = Utils::readLine($body);
if (!empty($line)) {
//callback
call_user_func($callback, $line);
}
if (ob_get_level() > 0) {
ob_flush();
}
flush();
}
}
public function testSkipsOverwrittenBytes()
{
$decorated = Stream::factory(implode("\n", array_map(function ($n) {
return str_pad($n, 4, '0', STR_PAD_LEFT);
}, range(0, 25))));
$body = new CachingStream($decorated);
$this->assertEquals("0000\n", Utils::readline($body));
$this->assertEquals("0001\n", Utils::readline($body));
// Write over part of the body yet to be read, so skip some bytes
$this->assertEquals(5, $body->write("TEST\n"));
$this->assertEquals(5, $this->readAttribute($body, 'skipReadBytes'));
// Read, which skips bytes, then reads
$this->assertEquals("0003\n", Utils::readline($body));
$this->assertEquals(0, $this->readAttribute($body, 'skipReadBytes'));
$this->assertEquals("0004\n", Utils::readline($body));
$this->assertEquals("0005\n", Utils::readline($body));
// Overwrite part of the cached body (so don't skip any bytes)
$body->seek(5);
$this->assertEquals(5, $body->write("ABCD\n"));
$this->assertEquals(0, $this->readAttribute($body, 'skipReadBytes'));
$this->assertEquals("TEST\n", Utils::readline($body));
$this->assertEquals("0003\n", Utils::readline($body));
$this->assertEquals("0004\n", Utils::readline($body));
$this->assertEquals("0005\n", Utils::readline($body));
$this->assertEquals("0006\n", Utils::readline($body));
$this->assertEquals(5, $body->write("1234\n"));
$this->assertEquals(5, $this->readAttribute($body, 'skipReadBytes'));
// Seek to 0 and ensure the overwritten bit is replaced
$body->seek(0);
$this->assertEquals("0000\nABCD\nTEST\n0003\n0004\n0005\n0006\n1234\n0008\n0009\n", $body->read(50));
// Ensure that casting it to a string does not include the bit that was overwritten
$this->assertContains("0000\nABCD\nTEST\n0003\n0004\n0005\n0006\n1234\n0008\n0009\n", (string) $body);
}
protected function getPayload(RequestInterface $request)
{
// Calculate the request signature payload
if ($request->hasHeader('x-amz-content-sha256')) {
// Handle streaming operations (e.g. Glacier.UploadArchive)
return (string) $request->getHeader('x-amz-content-sha256');
}
if ($body = $request->getBody()) {
if (!$body->isSeekable()) {
throw new CouldNotCreateChecksumException('sha256');
}
return Utils::hash($body, 'sha256');
}
return self::EMPTY_PAYLOAD;
}
/**
* Stream processor
*
* @access protected
* @param string $endpoint Streaming API endpoint
* @param Closure $handler Data handler
* @param \GuzzleHttp\Stream\StreamInterface $stream
* @return void
*/
protected function processor($endpoint, Closure $handler, StreamInterface $stream)
{
$stalled = time();
while (($line = Utils::readline($stream)) !== false) {
if (empty($line)) {
if (time() - $stalled > $this->stallTimeout) {
break;
}
continue;
}
// pass each line to the data handler
$handler(json_decode($line, $this->messageAsArray));
if ($this->triggerReconnection($endpoint)) {
break;
}
$stalled = time();
}
}
public function testTwitterStreamingIntegration()
{
if (empty($_SERVER['OAUTH_CONSUMER_SECRET'])) {
$this->markTestSkipped('No OAUTH_CONSUMER_SECRET provided in phpunit.xml');
return;
}
$client = new Client(['base_url' => 'https://stream.twitter.com/1.1/', 'defaults' => ['auth' => 'oauth']]);
$oauth = new Oauth1(['consumer_key' => $_SERVER['OAUTH_CONSUMER_KEY'], 'consumer_secret' => $_SERVER['OAUTH_CONSUMER_SECRET'], 'token' => $_SERVER['OAUTH_TOKEN'], 'token_secret' => $_SERVER['OAUTH_TOKEN_SECRET']]);
$client->getEmitter()->attach($oauth);
try {
$response = $client->post('statuses/filter.json', ['body' => ['track' => 'bieber'], 'stream' => true]);
$body = $response->getBody();
$data = Utils::readLine($body);
$this->assertContains('bieber', strtolower($data));
$this->assertNotEmpty(json_decode($data, true));
$body->close();
} catch (ClientException $e) {
if ($e->getResponse()->getStatusCode() == 429) {
$this->markTestIncomplete('You are being throttled');
} else {
throw $e;
}
}
}
protected function getCreatePartFn()
{
return function ($seekable) {
$data = [];
$firstByte = $this->source->tell();
// Read from the source to create the body stream. This also
// calculates the linear and tree hashes as the data is read.
if ($seekable) {
// Case 1: Stream is seekable, can make stream from new handle.
$body = Utils::open($this->source->getMetadata('uri'), 'r');
$body = $this->limitPartStream(Stream::factory($body));
// Create another stream decorated with hashing streams and read
// through it, so we can get the hash values for the part.
$decoratedBody = $this->decorateWithHashes($body, $data);
while (!$decoratedBody->eof()) {
$decoratedBody->read(1048576);
}
// Seek the original source forward to the end of the range.
$this->source->seek($this->source->tell() + $body->getSize());
} else {
// Case 2: Stream is not seekable, must store part in temp stream.
$source = $this->limitPartStream($this->source);
$source = $this->decorateWithHashes($source, $data);
$body = Stream::factory();
Utils::copyToStream($source, $body);
}
$body->seek(0);
$data['body'] = $body;
$lastByte = $this->source->tell() - 1;
$data['range'] = "bytes {$firstByte}-{$lastByte}/*";
return $data;
};
}
public function testProxiesToFactory()
{
$this->assertEquals('foo', (string) Utils::create('foo'));
}
/**
* {@inheritdoc}
*/
public function getColorProfile()
{
if (!in_array('icc', $this->imagick->getImageProfiles('*', false))) {
return null;
}
$data = $this->imagick->getImageProfile('icc');
return new ColorProfile(StreamUtils::create($data));
}
protected function getCreatePartFn()
{
return function ($seekable, $number) {
// Initialize the array of part data that will be returned.
$data = ['PartNumber' => $number];
// Read from the source to create the body stream.
if ($seekable) {
// Case 1: Source is seekable, use lazy stream to defer work.
$body = $this->limitPartStream(new LazyOpenStream($this->source->getMetadata('uri'), 'r'));
} else {
// Case 2: Stream is not seekable; must store in temp stream.
$source = $this->limitPartStream($this->source);
$source = $this->decorateWithHashes($source, function ($result, $type) use(&$data) {
$data['Content' . strtoupper($type)] = $result;
});
$body = Stream::factory();
Utils::copyToStream($source, $body);
$data['ContentLength'] = $body->getSize();
}
$body->seek(0);
$data['Body'] = $body;
return $data;
};
}
/**
* Determines if the body should be uploaded using PutObject or the
* Multipart Upload System. It also modifies the passed-in $body as needed
* to support the upload.
*
* @param StreamInterface $body Stream representing the body.
* @param integer $threshold Minimum bytes before using Multipart.
*
* @return bool
*/
private function requiresMultipart(StreamInterface &$body, $threshold)
{
// If body size known, compare to threshold to determine if Multipart.
if ($body->getSize() !== null) {
return $body->getSize() < $threshold ? false : true;
}
// Handle the situation where the body size is unknown.
// Read up to 5MB into a buffer to determine how to upload the body.
$buffer = Stream::factory();
Utils::copyToStream($body, $buffer, 5242880);
// If body < 5MB, use PutObject with the buffer.
if ($buffer->getSize() < 5242880) {
$buffer->seek(0);
$body = $buffer;
return false;
}
// If >= 5 MB, and seekable, use Multipart with rewound body.
if ($body->isSeekable()) {
$body->seek(0);
return true;
}
// If >= 5 MB, and non-seekable, use Multipart, but stitch the
// buffer and the body together into one stream. This avoids
// needing to seek and unnecessary disc usage, while requiring
// only the 5 MB buffer to be re-read by the Multipart system.
$buffer->seek(0);
$body = new AppendStream([$buffer, $body]);
return true;
}
