Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Flujos en la versión 3 de AWS SDK for PHP

Como parte de su integración del estándar de mensajes HTTP PSR-7, AWS SDK for PHP utiliza StreamInterface PSR-7 internamente como su abstracción en los flujos de PHP. Cualquier comando que disponga de un campo de entrada definido como blob, como el parámetro Body en un comando S3::PutObject, puede cumplirse con una cadena, un recurso de flujo de PHP o una instancia de Psr\Http\Message\StreamInterface.

Decoradores de flujo

Guzzle proporciona varios decoradores de flujo que puede utilizar para controlar la forma en que el SDK y Guzzle interactúan con el recurso de flujo suministrado como parámetro de entrada a un comando. Estos decoradores pueden modificar la forma en que los controladores leen y buscan un flujo determinado. A continuación se muestra una lista parcial; encontrará más información en el repositorio GuzzleHttpPsr7.

AppendStream

GuzzleHttp\Psr7\AppendStream

Lee varios flujos, uno detrás del otro.

use GuzzleHttp\Psr7;

$a = Psr7\stream_for('abc, ');
$b = Psr7\stream_for('123.');
$composed = new Psr7\AppendStream([$a, $b]);

$composed->addStream(Psr7\stream_for(' Above all listen to me'));

echo $composed(); // abc, 123. Above all listen to me.

CachingStream

GuzzleHttp\Psr7\CachingStream

Se utiliza para permitir la búsqueda de bytes leídos previamente en flujos no rastreables. Esto puede resultar útil cuando la transferencia de un cuerpo de entidad no rastreable falla debido a la necesidad de rebobinar el flujo (por ejemplo, debido a un redireccionamiento). Los datos que se leen en el flujo remoto se almacenan en búfer en un flujo temporal de PHP, de modo que los bytes leídos previamente se almacenan primero en caché en la memoria y luego en el disco.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for(fopen('http://www.google.com', 'r'));
$stream = new Psr7\CachingStream($original);

$stream->read(1024);
echo $stream->tell();
// 1024

$stream->seek(0);
echo $stream->tell();
// 0

InflateStream

GuzzleHttp\Psr7\InflateStream

Utiliza el filtro zlib.inflate de PHP para inflar o desinflar contenido comprimido en un zip.

Este decorador de flujos omite los primeros 10 bytes del flujo dado para eliminar el encabezado gzip, convierte el flujo proporcionado en un recurso de flujo de PHP y, a continuación, añade el filtro zlib.inflate. El flujo se vuelve a convertir en un recurso de flujo de Guzzle que se va a utilizar como flujo de Guzzle.

LazyOpenStream

GuzzleHttp\Psr7\LazyOpenStream

Lee o escribe lentamente en un archivo que se abre después de que se produzca una operación de E/S en el flujo.

use GuzzleHttp\Psr7;

$stream = new Psr7\LazyOpenStream('/path/to/file', 'r');
// The file has not yet been opened...

echo $stream->read(10);
// The file is opened and read from only when needed.

LimitStream

GuzzleHttp\Psr7\LimitStream

Se utiliza para leer un subconjunto o sector de un objeto de flujo existente. Esto puede resultar útil para dividir un archivo de gran tamaño en partes más pequeñas que se envían en fragmentos (por ejemplo, la API de carga multiparte de Amazon S3).

use GuzzleHttp\Psr7;

$original = Psr7\stream_for(fopen('/tmp/test.txt', 'r+'));
echo $original->getSize();
// >>> 1048576

// Limit the size of the body to 1024 bytes and start reading from byte 2048
$stream = new Psr7\LimitStream($original, 1024, 2048);
echo $stream->getSize();
// >>> 1024
echo $stream->tell();
// >>> 0

NoSeekStream

GuzzleHttp\Psr7\NoSeekStream

Encapsula un flujo y no permite que se encuentre.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for('foo');
$noSeek = new Psr7\NoSeekStream($original);

echo $noSeek->read(3);
// foo
var_export($noSeek->isSeekable());
// false
$noSeek->seek(0);
var_export($noSeek->read(3));
// NULL

PumpStream

GuzzleHttp\Psr7\PumpStream

Proporciona un flujo de solo lectura que bombea datos desde una función invocable de PHP.

Al invocar la función invocable proporcionada, PumpStream pasa la cantidad de datos solicitados a leer a la función invocable. La función invocable puede elegir omitir este valor y devolver más o menos bytes de los solicitados. Los datos adicionales que devuelve la función invocable proporcionada se almacenan en el búfer internamente hasta que se vacíe utilizando la función read() de PumpStream. La función invocable proporcionada DEBE devolver el valor false cuando ya no queden datos por leer.

Implementar decoradores de flujo

Crear un decorador de flujos es una tarea muy sencilla gracias a la característica GuzzleHttp\Psr7\StreamDecoratorTrait. Esta característica proporciona métodos que implementan Psr\Http\Message\StreamInterface al conectar mediante proxy con un flujo subyacente. Simplemente use la característica StreamDecoratorTrait e implemente sus métodos personalizados.

Por ejemplo, supongamos que quiere llamar a una función específica cada vez que se lea el último byte de un flujo. Esto podría implementarse anulando el método read().

use Psr\Http\Message\StreamInterface;
use GuzzleHttp\Psr7\StreamDecoratorTrait;

class EofCallbackStream implements StreamInterface
{
    use StreamDecoratorTrait;

    private $callback;

    public function __construct(StreamInterface $stream, callable $cb)
    {
        $this->stream = $stream;
        $this->callback = $cb;
    }

    public function read($length)
    {
        $result = $this->stream->read($length);

        // Invoke the callback when EOF is hit
        if ($this->eof()) {
            call_user_func($this->callback);
        }

        return $result;
    }
}

Este decorador se podría agregar a cualquier flujo existente y utilizarse del siguiente modo.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for('foo');

$eofStream = new EofCallbackStream($original, function () {
    echo 'EOF!';
});

$eofStream->read(2);
$eofStream->read(1);
// echoes "EOF!"
$eofStream->seek(0);
$eofStream->read(3);
// echoes "EOF!"