streaming results from the CPAN


my %stat = (
	':-)' => 'Normal operation, low/no jitter',
	':-|' => 'Normal operation, considerable jitter',
	':-/' => 'Read drift',
	':-P' => 'Unreported loss of streaming in atomic read operation',
	'8-|' => 'Finding read problems at same point during reread; hard to correct',
	':-0' => 'SCSI/ATAPI transport error',
	':-(' => 'Scratch detected',
	';-(' => 'Gave up trying to perform a correction',
	'8-X' => 'Aborted (as per -X) due to a scratch/skip',

view all matches for this distribution

POE-Component-Client-HTTP

5 results

lib/POE/Component/Client/HTTP.pm view on Meta::CPAN

chunks (of OCTETS octets each) rather than combine the entire content
into a single HTTP::Response object.

By default, Client::HTTP reads the entire content for a response into
memory before returning an HTTP::Response object.  This is obviously
bad for applications like streaming MP3 clients, because they often
fetch songs that never end.  Yes, they go on and on, my friend.

When C<Streaming> is set to nonzero, however, the response handler
receives chunks of up to OCTETS octets apiece.  The response handler
accepts slightly different parameters in this case.  ARG0 is also an
HTTP::Response object but it does not contain response content,
and ARG1 contains a a chunk of raw response
content, or undef if the stream has ended.

  sub streaming_response_handler {
    my $response_packet = $_[ARG1];
    my ($response, $data) = @$response_packet;
    print SAVED_STREAM $data if defined $data;
  }

lib/POE/Component/Client/HTTP.pm view on Meta::CPAN


=head2 cancel

Cancel a specific HTTP request.  Requires a reference to the original
request (blessed or stringified) so it knows which one to cancel.  See
L<progress handler> below for notes on canceling streaming requests.

To cancel a request based on its blessed HTTP::Request object:

  $kernel->post( component => cancel => $http_request );

view all matches for this distribution

POE-Component-Client-Icecast

2 results

lib/POE/Component/Client/Icecast.pm view on Meta::CPAN

    POE::Kernel->run;


=head1 DESCRIPTION

The module is a non-blocking client to Icecast streaming multimedia server for getting stream tags.

See L<http://www.icecast.org/>.

POE::Component::Client::Icecast is based on L<POE::Component::Client::TCP>.

view all matches for this distribution

POE-Component-Curl-Multi

2 results

lib/POE/Component/Curl/Multi.pm view on Meta::CPAN

    return;
  }

=head1 STREAMING

This component does not (yet) support L<POE::Component::Client::HTTP>'s streaming options.

=head1 CLIENT HEADERS

POE::Component::Curl::Multi sets its own response headers with
additional information.  All of its headers begin with "X-PCCH".

view all matches for this distribution

POE-Component-FastCGI

3 results

lib/POE/Component/FastCGI.pm view on Meta::CPAN

       $kernel->post($heap->{Session}, $run->[1],$request, $run->[0]);
     }

	 if($request->{_res}) {
		 # Streaming support
		 if($request->{_res}->streaming) {
			 push @{$heap->{toclose}->{$wheel_id}}, $request->{_res};
		 } else {
			 # Send and break circular ref
			 $request->{_res}->send if exists $request->{_res}->{client};
			 $request->{_res} = 0;

view all matches for this distribution

POE-Component-Server-Bayeux

1 match

lib/POE/Component/Server/Bayeux/Request.pm view on Meta::CPAN


    if ($self->delay) {
        $poe_kernel->post($heap->{manager}, 'delay_request', $self->id, $self->delay);
        $self->delay(0);
        $self->is_complete(0);
        $self->http_response->streaming(1);
    }
    else {
        $self->complete();
    }
}

lib/POE/Component/Server/Bayeux/Request.pm view on Meta::CPAN

sub complete {
    my ($self) = @_;

    $self->form_response( @{ $self->responses } );
    $self->is_complete(1);
    if ($self->http_response->streaming) {
        $self->http_response->send( $self->http_response );
        $self->http_response->close();
    }

    # Ensure no KeepAlive

view all matches for this distribution

POE-Component-Server-HTTP

5 results

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN

                }
            }
            next;
        }
        elsif ($state eq 'Cleanup') {
            if (not $response->is_error and $response->streaming()) {
                $_[HEAP]->{wheels}->{$id}->set_output_filter(POE::Filter::Stream->new() );
                unshift(@{$handlers->{Queue}},'Streaming');
                next HANDLERS;
            }

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN


    $response->header(%{$self->{Headers}});
    unless ($response->header('Date')) {
        $response->header('Date',time2str(time));
    }
    if (!($response->header('Content-Lenth')) && !($response->streaming())) {
        use bytes;
        $response->header('Content-Length',length($response->content));
    }

    $wheel->put($response);

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN


If no handler installs a ContentHandler it will find the closest one
directory wise and use it.

There is also a special StreamHandler which is a coderef that gets
invoked if you have turned on streaming by doing
$response->streaming(1);

Handlers take the $request and $response objects as arguments.

=over 4

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN

=item ContentHandler

The handler that is supposed to give the content. When this handler
returns it will send the response object to the client. It will
automaticly add Content-Length and Date if these are not set. If the
response is streaming it will make sure the correct headers are
set. It will also expand any cookies which have been pushed onto the
response object.

    new(ContentHandler => { '/' => sub {}, '/foo/' => \&foo});

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN

    new(PostHandler => { '/' => [sub {}], '/foo/' => [\&foo]});


=item StreamHandler

If you turn on streaming in any other handler, the request is placed in
streaming mode.  This handler is called, with the usual parameters, when
streaming mode is first entered, and subsequently when each block of data is
flushed to the client.

Streaming mode is turned on via the C<$response> object:

    $response->streaming(1);

You deactivate streaming mode with the same object:

    $response->close;

Content is also sent to the client via the C<$response> object:

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN

    }

    sub someurl {
        my($self, $resquest, $response)=@_;
        $self->{todo} = [ .... ];
        $response->streaming(1);
        $response->code(RC_OK);         # you must set up your response header
        $response->content_type(...);

        return RC_OK;
    }

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN

    }

Another example can be found in t/30_stream.t.  The parts dealing with
multipart/mixed are well documented and at the end of the file.

NOTE: Changes in streaming mode are only verified when StreamHandler exits.
So you must either turn streaming off in your StreamHandler, or make sure
that the StreamHandler will be called again.  This last is done by sending
data to the client.  If for some reason you have no data to send, you can
get the same result with C<continue>. Remember that this will also cause the
StreamHandler to be called one more time.

lib/POE/Component/Server/HTTP.pm view on Meta::CPAN


=item Write more tests

=item Add a PoCo::Server::HTTP::Session that matches a http session against poe session using cookies or other state system

=item Add more options to streaming

=item Figure out why post()ed C<shutdown> events don't get received.

=item Probably lots of other API changes

view all matches for this distribution

POE-Component-Server-SimpleHTTP-PreFork

1 match

t/03_prefork_stream.t view on Meta::CPAN

}

sub GOT_STREAM {
   my ( $kernel, $heap, $response ) = @_[KERNEL, HEAP, ARG0];

   # lets go on streaming ...
   if ($heap->{'count'} <= 2) {
      my $text = "Hello World ".$heap->{'count'}." \n";
    #  print "send ".$text."\n";
      $response->content($text);

view all matches for this distribution

POE-Component-Server-SimpleHTTP

10 results

examples/stream.pl view on Meta::CPAN

   
   # the stream hash contains the wheel, the request, the response 
   # and an id associated the the wheel
   $stream->{'wheel'}->put("Hello World\n");

   # lets go on streaming ...
   POE::Kernel->delay('GOT_STREAM', 1, $stream );
}

view all matches for this distribution

POE-Declare-Log-File

1 match

lib/POE/Declare/Log/File.pm view on Meta::CPAN

	$_[SELF]->{state} = 'CRASH';

	# Prevent additional message and flush queue
	delete $_[SELF]->{buffer};

	# Clean up streaming resources
	$_[SELF]->clean;

	return;
}

lib/POE/Declare/Log/File.pm view on Meta::CPAN

	my $self = shift;

	# Prevent additional messages and flush the queue
	delete $self->{buffer};

	# Clean up streaming resources
	$self->clean;

	# Pass through as normal
	$self->SUPER::finish(@_);
}

view all matches for this distribution

POE-Filter-XML

5 results

    builder => '_build_parser',
    clearer => '_clear_parser'
);


has not_streaming =>
(
    is => 'ro',
    isa => 'Bool',
    default => 0,
);

sub _build_handler {
    my ($self) = @_;
    POE::Filter::XML::Handler->new(not_streaming => $self->not_streaming)
}

sub _build_parser {
    my ($self) = @_;
    XML::LibXML->new(Handler => $self->handler)


            if($self->handler->has_finished_nodes())
            {
                my $node = $self->handler->get_finished_node();

                if($node->stream_end() or $self->not_streaming)
                {
                    $self->parser->parse_chunk('', 1);
                    $self->reset();
                }


The parser is XML::LibXML

=head1 PUBLIC_ATTRIBUTES

=head2 not_streaming

    is: ro, isa: Bool, default: false

Setting the not_streaming attribute to true via new() will put this filter into
non-streaming mode, meaning that whole documents are parsed before nodes are
returned. This is handy for XMLRPC or other short documents.

=head1 PRIVATE_ATTRIBUTES

=head2 buffer

    is: ro, isa: POE::Filter::XML::Handler

handler holds the SAX handler to be used for processing events from the parser.
By default POE::Filter::XML::Handler is instantiated and used.

The L</not_streaming> attribute is passed to the constructor of Handler.

=head2 parser

    is: ro, isa: XML::LibXML

reset() is an internal method that gets called when either a stream_start(1)
POE::Filter::XML::Node gets placed into the filter via L</put>, or when a
stream_end(1) POE::Filter::XML::Node is pulled out of the queue of finished
Nodes via L</get_one>. This facilitates automagical behavior when using the
Filter within the XMPP protocol that requires many new stream initiations.
This method is also called after every document when not in streaming mode.
Useful for handling XMLRPC processing.

This method really should never be called outside of the Filter, but it is
documented here in case the Filter is used outside of the POE context.

view all matches for this distribution

POE-Filter-Zlib

3 results

lib/POE/Filter/Zlib.pm view on Meta::CPAN

=head1 DESCRIPTION

POE::Filter::Zlib provides a POE filter for performing compression/uncompression using L<Compress::Zlib>. It is
suitable for use with L<POE::Filter::Stackable>.

This filter is not ideal for streaming compressed data over sockets etc. as it employs compress and uncompress zlib functions.

L<POE::Filter::Zlib::Stream> is recommended for that type of activity.

=head1 CONSTRUCTOR

view all matches for this distribution

POEx-HTTP-Server

5 results

    # Request has finished
    if( not $self->{resp} or $self->{S}{done} or $self->{resp}->finished ) {
        return $self->finish_request;
    }

    # streaming?
    elsif( $self->{resp}->streaming ) {     
        return $self->send_more;        # send some more
    }

    # The last possiblity is that calls to ->send have filled up the Wheel's
    # or the driver's buffer and it was flushed.

        #my $conn = $self->{req}->header('Connection')||'';
        #$self->{will_close} = 0 if qq(,$conn,) =~ /,\s*keep-alive\s*,/i;
        #warn "$$:conn=$conn will_close=$self->{will_close}";
    }

    $self->{will_close} = 1 if $self->{resp}->streaming;
    #warn "$$:post streaming will_close=$self->{will_close}";
    $self->{will_close} = 1 unless $self->{keepalive} > 1;
    #warn "$$:post keepalive will_close=$self->{will_close}";
    $self->{will_close} = 1 if $self->{shutdown};
    DEBUG and 
        $self->D( "will_close=$self->{will_close}" );

    unless( $self->{resp}->headers_sent ) {
        $self->should_close;
        $self->send_headers;
        $self->{stream_wheel} = 1;
        $self->{wheel}->set_output_filter( $self->build_stream_filter );
        if( $self->{resp}->streaming ) {
            eval { 
                $SIG{__DIE__} = 'DEFAULT'; 
                $self->__tcp_hot;
            };
            warn $@ if $@;
        }
    }

    $self->output( $something ) if defined $something;
    if( $self->{resp}->streaming and $self->{wheel} ) {
        $self->{wheel}->flush;            
    }
    $self->timeout_start();
    return;
}

# We are in streaming mode.  The last chunk has flushed.  Send a new one
sub send_more
{
    my( $self ) = @_;
    $self->timeout_stop();
    $self->special_dispatch( 'stream_request', $self->{req}, $self->{resp} );
}


# We are in streaming mode.  Turn off Nagle's algorithm
# This isn't as effective as you might think
sub __tcp_hot
{
    my( $self ) = @_;
    DEBUG and

        # ...
    }

=head3 stream_request

Invoked when a chunk has been flushed to the OS, if you are streaming a
response to the browser.  Streaming is turned on with
L<POEx::HTTP::Server::Response/streaming>.

Please remember that while a chunk might be flushed, the OS's network layer
might still decide to combine several chunks into a single packet.  And this
even though we setup a I<hot> socket with C<TCP_NODELAY> set to 1 and
C<SO_SNDBUF> to 576.

keepalive is deactivated for the connection.  Finally difference
is that you will see C<L</stream_request>> when you are allowed to send the
next block. Look for C<L</post_request>> to find out when the last block has
been sent to the browser.

    $resp->streaming( 1 );
    $resp->header( 'Content-Length' => $size );
    $resp->send;

When you want to send a chunk:

view all matches for this distribution

POEx-Role-PSGIServer

5 results

lib/POEx/Role/PSGIServer.pm view on Meta::CPAN

        return req_to_psgi(
            $c->{request},
            SERVER_NAME         => $self->listen_ip,
            SERVER_PORT         => $self->listen_port,
            SERVER_PROTOCOL     => $c->{protocol},
            'psgi.streaming'    => Plack::Util::TRUE,
            'psgi.nonblocking'  => Plack::Util::TRUE,
            'psgi.runonce'      => Plack::Util::FALSE,
        );
    }

lib/POEx/Role/PSGIServer.pm view on Meta::CPAN


POEx::Role::PSGIServer encapsulates the core L<PSGI> server behaviors into an easy to consume and extend role. It is based on previous POEx work such as POEx::Role::TCPServer which provides basic TCP socket multiplexing via POE::Wheel::SocketFactory ...

=head2 RATIONALE

This Role has its roots firmly planted in POE::Component::Server::PSGI which provided the initial seed with the layout and logic of the basic server. Unfortunately, POE::Component::Server::PSGI didn't provide any mechnism for extension. The main goal...

=head1 CLASS_METHODS

=head2 around BUILDARGS

view all matches for this distribution

PSGI

3 results

Changes view on Meta::CPAN

      - 1.1 beta
      - Upped psgi.version to be [1,1]
      - Lots of grammar and style fixes
      - Removed poll_cb from writer spec
      - Streaming interface now SHOULD be implemented, rather than MAY
      - Promoted psgi.streaming, nonblocking and run_once keys to be MUST
      - Added psgix.logger and psgix.session extensions
      - Updated FAQ

1.03  Tue Oct 27 13:44:01 PDT 2009
      - Added an optional callback interface to allow delayed response and streaming

1.02  Tue Oct 13 01:57:28 PDT 2009
      - No spec changes. Just to let PAUSE index this stuff.

1.01  Tue Oct 13 01:17:28 PDT 2009

view all matches for this distribution

Padre-Plugin-Plack

1 match

share/dot-psgi/echo-stream.psgi view on Meta::CPAN

use AnyEvent;
my $app = sub {
    my $env = shift;

    warn "This app needs a server that supports psgi.streaming"
        unless $env->{'psgi.streaming'};

    my $cv = AE::cv;
    return sub {
        my $respond = shift;
        my $w = $respond->([ 200, ['X-Foo' => 'bar', 'Content-Type' => 'text/plain'] ]);

view all matches for this distribution

Padre-Plugin-WxWidgets

1 match

share/doc/wxwidgets.pod view on Meta::CPAN

   virtual istream& LoadObject(istream& stream)

   virtual wxInputStream& LoadObject(wxInputStream& stream)

   Override this function and call it from your own LoadObject before
   streaming your own data. LoadObject is called by the framework
   automatically when the document contents need to be loaded.

   Note that only one of these forms exists, depending on how wxWidgets
   was configured.

share/doc/wxwidgets.pod view on Meta::CPAN

   virtual ostream& SaveObject(ostream& stream)

   virtual wxOutputStream& SaveObject(wxOutputStream& stream)

   Override this function and call it from your own SaveObject before
   streaming your own data. SaveObject is called by the framework
   automatically when the document contents need to be saved.

   Note that only one of these forms exists, depending on how wxWidgets
   was configured.

share/doc/wxwidgets.pod view on Meta::CPAN

   and then call wxMediaCtrl::Play to show the video/audio of the media
   in that event.

   More complex operations are generally more heavily dependant on the
   capabilities of the backend. For example, QuickTime cannot set the
   playback rate of certain streaming media - while DirectShow is
   slightly more flexible in that regard.

=head2 Operation

   When wxMediaCtrl plays a file, it plays until the stop position is

view all matches for this distribution

Padre

2 results

lib/Padre/Task/Run.pm view on Meta::CPAN

package Padre::Task::Run;

# Generic task for executing programs via system() and streaming
# their output back to the main program.

use 5.008005;
use strict;
use warnings;

view all matches for this distribution

Parley

5 results

root/static/yui/charts/charts-debug.js view on Meta::CPAN

		}
		return "";
	}
};

/* fix for video streaming bug */
YAHOO.deconcept.SWFObjectUtil.cleanupSWFs = function()
{
	var objects = document.getElementsByTagName("OBJECT");
	for(var i = objects.length - 1; i >= 0; i--)
	{

view all matches for this distribution

Parse-CSV

1 match

lib/Parse/CSV.pm view on Meta::CPAN

This method is fine unless your CSV files start to get large. Once that
happens, the only existing option is to fall back on the relatively slow
and heavyweight L<XML::SAXDriver::CSV> module.

L<Parse::CSV> fills this functionality gap. It provides a flexible
and light-weight streaming parser for large, extremely large, or
arbitrarily large CSV files.

=head2 Main Features

B<Stream-Based Parser> - All parsing a line at a time.

view all matches for this distribution

Parse-DebControl

2 results

lib/Parse/DebControl.pm view on Meta::CPAN


=item * CHANGES file now generated automatically

=item * Fixes for potential test suite failure in Pod::Coverage run

=item * Adds the "addNewline" option to write_file to solve the streaming stanza problem.

=item * Adds tests for the addNewline option

=back

view all matches for this distribution

Parse-Gnaw

1 match

lib/Parse/Gnaw/Blocks/ParsingMethods.pm view on Meta::CPAN

read in the entire stream (petabytes) into memory and crash the system.
if it doesn't crash, it will back up until it finds  amatch.
We default to thrifty matching, meaning we only read in as little as possible
to still find a match. This means we only read in just as much of the
stream as we need to find a match.
We can DO greedy matching, but it can be a problem if we're streaming massive quantities of data.

basic thrifty algorithm:
try the rule at least min times.
if that matches, then return and let rest of grammar try.
If rest of grammar dies, then revert to min location

view all matches for this distribution

Parse-M3U-Extended

1 match

lib/Parse/M3U/Extended.pm view on Meta::CPAN


=head1 SEE ALSO

=over

=item * IETF Internet Draft: draft-pantos-http-live-streaming-08

=back

=head1 COPYRIGHT

view all matches for this distribution

Parse-NetApp-ASUP

5 results

examples/7.0.3/asup01.txt view on Meta::CPAN

Sat Mar 17 21:00:00 PDT [oren-netapp: kern.uptime.filer:info]:   9:00pm up 963 days,  9:06 204327914692 NFS ops, 0 CIFS ops, 694 HTTP ops, 0 DAFS ops, 0 FCP ops, 0 iSCSI ops
Sat Mar 17 22:00:00 PDT [oren-netapp: kern.uptime.filer:info]:  10:00pm up 963 days, 10:06 204340168883 NFS ops, 0 CIFS ops, 694 HTTP ops, 0 DAFS ops, 0 FCP ops, 0 iSCSI ops
Sat Mar 17 23:00:00 PDT [oren-netapp: kern.uptime.filer:info]:  11:00pm up 963 days, 11:06 204344688894 NFS ops, 0 CIFS ops, 694 HTTP ops, 0 DAFS ops, 0 FCP ops, 0 iSCSI ops
Sun Mar 18 00:00:00 PDT [oren-netapp: kern.uptime.filer:info]:  12:00am up 963 days, 12:06 204348443008 NFS ops, 0 CIFS ops, 694 HTTP ops, 0 DAFS ops, 0 FCP ops, 0 iSCSI ops

<perf-info><object-info><objectname>system</objectname><counters><counter-info><name>nfs_ops</name><desc>NFS operations per second</desc><privilege-level>basic</privilege-level><properties>rate</properties><unit>per_sec</unit></counter-info><counter-...

view all matches for this distribution

Parse-SAMGov

1 match

Changes view on Meta::CPAN

0.202     2023-11-27 07:23:21-05:00 America/New_York

0.106     2016-08-07 19:19:46-04:00 America/New_York

    Adding an is_smallbiz() function to check for small business.
    Adding a script to demonstrate streaming use of data

0.105     2016-08-07 17:04:51-04:00 America/New_York

    Fixing documentation error. Adding an example script

view all matches for this distribution

Parse-WBXML

1 match

lib/Parse/WBXML.pm view on Meta::CPAN

the other modules in L</SEE ALSO> first. The current API may change before the 1.0
release.

Provides a pure-Perl implementation for the WBXML compressed XML format.
Slower and less efficient than the libwbxml2-based alternatives (L</SEE ALSO>),
but supports streaming SAX-like parsing.

This may be of some use in low-bandwidth situations where you want data as soon
as available from the stream, or in cases where the document is damaged and you
want to recover as much data as possible, or if you just don't have libwbxml2
available.

view all matches for this distribution

Paws

214 results

Amazon AppStream 2.0

This is the I<Amazon AppStream 2.0 API Reference>. This documentation
provides descriptions and syntax for each of the actions and data types
in AppStream 2.0. AppStream 2.0 is a fully managed, secure application
streaming service that lets you stream desktop applications to users
without rewriting applications. AppStream 2.0 manages the AWS resources
that are required to host and run your applications, scales
automatically, and provides access to your users on demand.

You can call the AppStream 2.0 API operations by using an interface VPC


Each argument is described in detail in: L<Paws::AppStream::CreateFleet>

Returns: a L<Paws::AppStream::CreateFleetResult> instance

Creates a fleet. A fleet consists of streaming instances that run a
specified image.


=head2 CreateImageBuilder


Each argument is described in detail in: L<Paws::AppStream::CreateImageBuilderStreamingURL>

Returns: a L<Paws::AppStream::CreateImageBuilderStreamingURLResult> instance

Creates a URL to start an image builder streaming session.


=head2 CreateStack

=over


Each argument is described in detail in: L<Paws::AppStream::CreateStack>

Returns: a L<Paws::AppStream::CreateStackResult> instance

Creates a stack to start streaming applications to users. A stack
consists of an associated fleet, user access policies, and storage
configurations.


=head2 CreateStreamingURL


Each argument is described in detail in: L<Paws::AppStream::CreateStreamingURL>

Returns: a L<Paws::AppStream::CreateStreamingURLResult> instance

Creates a temporary URL to start an AppStream 2.0 streaming session for
the specified user. A streaming URL enables application streaming to be
tested without user setup.


=head2 CreateUpdatedImage

Each argument is described in detail in: L<Paws::AppStream::DeleteDirectoryConfig>

Returns: a L<Paws::AppStream::DeleteDirectoryConfigResult> instance

Deletes the specified Directory Config object from AppStream 2.0. This
object includes the information required to join streaming instances to
an Active Directory domain.


=head2 DeleteFleet

Each argument is described in detail in: L<Paws::AppStream::DeleteStack>

Returns: a L<Paws::AppStream::DeleteStackResult> instance

Deletes the specified stack. After the stack is deleted, the
application streaming environment provided by the stack is no longer
available to users. Also, any reservations made for application
streaming sessions for the stack are released.


=head2 DeleteUsageReportSubscription


Each argument is described in detail in: L<Paws::AppStream::DescribeSessions>

Returns: a L<Paws::AppStream::DescribeSessionsResult> instance

Retrieves a list that describes the streaming sessions for a specified
stack and fleet. If a UserId is provided for the stack and fleet, only
streaming sessions for that user are described. If an authentication
type is not provided, the default is to authenticate users using a
streaming URL.


=head2 DescribeStacks

=over


Each argument is described in detail in: L<Paws::AppStream::ExpireSession>

Returns: a L<Paws::AppStream::ExpireSessionResult> instance

Immediately stops the specified streaming session.


=head2 ListAssociatedFleets

=over

view all matches for this distribution

PawsX-Waiter

1 match

lib/PawsX/Waiter/waiters.json view on Meta::CPAN

{"mediaconnect":{"2018-11-14":{"FlowActive":{"description":"Wait until a flow is active","acceptors":[{"state":"success","expected":"ACTIVE","matcher":"path","argument":"Flow.Status"},{"state":"retry","expected":"STARTING","matcher":"path","argument"...

view all matches for this distribution

Perinci-Access-HTTP-Server

1 match

lib/Plack/Middleware/PeriAHS/Respond.pm view on Meta::CPAN

sub call {
    log_trace("=> PeriAHS::Respond middleware");

    my ($self, $env) = @_;

    die "This middleware needs psgi.streaming support"
        unless $env->{'psgi.streaming'};

    my $rreq = $env->{"riap.request"};
    my $pa   = $env->{"periahs.riap_client"}
        or die "\$env->{'periahs.riap_client'} not defined, ".
            "perhaps ParseRequest middleware has not run?";

view all matches for this distribution

Perinci-CmdLine

3 results