streaming results from the CPAN

    neo4j_memory_allocator_t *allocator;
    neo4j_mpool_t mpool;
    neo4j_mpool_t record_mpool;
    unsigned int refcount;
    unsigned int starting;
    unsigned int streaming;
    int statement_type;
    struct neo4j_statement_plan *statement_plan;
    struct neo4j_update_counts update_counts;
    unsigned long long available_after;
    unsigned long long consumed_after;

        goto failure;
    }
    (results->refcount)++;

    results->starting = true;
    results->streaming = true;
    return &(results->_result_stream);

    int errsv;
failure:
    errsv = errno;

        goto failure;
    }
    (results->refcount)++;

    results->starting = true;
    results->streaming = true;
    return &(results->_result_stream);

    int errsv;
failure:
    errsv = errno;

        results->last_fetched = NULL;
    }

    if (results->records == NULL)
    {
        if (!results->streaming)
        {
            errno = results->failure;
            return NULL;
        }
        assert(results->failure == 0);

            errno = results->failure;
            return NULL;
        }
        if (results->records == NULL)
        {
            assert(!results->streaming);
            errno = results->failure;
            return NULL;
        }
    }

            run_result_stream_t, _result_stream);
    REQUIRE(results != NULL, NULL);

    if (results->records_depth <= depth)
    {
        if (!results->streaming)
        {
            errno = results->failure;
            return NULL;
        }

            return NULL;
        }

        if (results->records_depth <= depth)
        {
            assert(!results->streaming);
            errno = results->failure;
            return NULL;
        }
    }

{
    run_result_stream_t *results = container_of(self,
            run_result_stream_t, _result_stream);
    REQUIRE(results != NULL, 0);

    if (results->failure != 0 || await(results, &(results->streaming)))
    {
        assert(results->failure != 0);
        errno = results->failure;
        return 0;
    }

{
    run_result_stream_t *results = container_of(self,
            run_result_stream_t, _result_stream);
    REQUIRE(results != NULL, -1);

    if (results->failure != 0 || await(results, &(results->streaming)))
    {
        assert(results->failure != 0);
        errno = results->failure;
        return -1;
    }

{
    run_result_stream_t *results = container_of(self,
            run_result_stream_t, _result_stream);
    REQUIRE(results != NULL, NULL);

    if (results->failure != 0 || await(results, &(results->streaming)))
    {
        assert(results->failure != 0);
        errno = results->failure;
        return NULL;
    }

    {
        errno = EINVAL;
        goto failure;
    }

    if (results->failure != 0 || await(results, &(results->streaming)))
    {
        assert(results->failure != 0);
        errno = results->failure;
        goto failure;
    }

{
    run_result_stream_t *results = container_of(self,
            run_result_stream_t, _result_stream);
    REQUIRE(results != NULL, -1);

    results->streaming = false;
    assert(results->refcount > 0);
    --(results->refcount);
    int err = await(results, &(results->refcount));
    // even if await fails, queued messages should still be drained
    assert(results->refcount == 0);

        return;
    }

    job->next = NULL;
    results->connection = NULL;
    if (results->streaming && results->failure == 0)
    {
        set_failure(results, err);
    }
}

        }
        return 1;
    }

    --(results->refcount);
    results->streaming = false;

    // not a record, so keep this memory along with the result stream
    if (neo4j_mpool_merge(&(results->mpool), &(results->record_mpool)) < 0)
    {
        neo4j_log_trace_errno(results->logger, "neo4j_mpool_merge failed");

    assert(cdata != NULL);
    assert(argc == 0 || argv != NULL);
    run_result_stream_t *results = (run_result_stream_t *)cdata;

    --(results->refcount);
    results->streaming = false;

    return stream_end(results, type, "DISCARD_ALL", argv, argc);
}

        return -1;
    }

    (results->nrecords)++;

    if (!results->streaming)
    {
        // discard memory for the record
        neo4j_mpool_drain(&(results->record_mpool));
        return 0;
    }

void set_failure(run_result_stream_t *results, int error)
{
    assert(results != NULL);
    assert(error != 0);
    results->failure = error;
    results->streaming = false;
    results->awaiting_records = 0;
    memset(&(results->failure_details), 0, sizeof(results->failure_details));
}

view all matches for this distribution

Neo4j-Driver

1 match

 - deprecate experimental suppression of exceptions (die_on_error = 0)

0.13  2019-10-14

 - declare API stable
 - add record streaming interface to StatementResult
 - implement Cypher type system, returning Neo4j entities as blessed objects
 - methods returning lists now expect to be called in list context
 - change HTTP transactions to make query statistics available by default
 - experimental support for HTTPS

view all matches for this distribution

Net-AMQP-PP

1 match

lib/Net/AMQP/PP.pm view on Meta::CPAN

use JSON ();

our $VERSION = '0.01';

my $data = JSON::from_json(
q[{"domain":{"delivery tag":{"type":"longlong"},"exchange name":{"type":"shortstr"},"reply code":{"type":"short"},"consumer tag":{"type":"shortstr"},"path":{"type":"shortstr"},"class id":{"type":"short"},"access ticket":{"type":"short"},"queue name":...

sub import {
    local $INC{"XML/LibXML.pm"} = 1;
    require Net::AMQP;
    require Net::AMQP::Protocol;

view all matches for this distribution

Net-AMQP

5 results


=item I<consume_rate> (type: long)

Transfer rate in octets/second 

Specifies a desired transfer rate in octets per second. This is usually determined by the application that uses the streaming data. A value of zero means "no limit", i.e. as rapidly as possible. 

=item I<global> (type: bit)

Apply to entire connection

    <!--
======================================================
==       STREAMING
======================================================
-->
  work with streaming content

<doc>
  The stream class provides methods that support multimedia streaming.
  The stream class uses the following semantics: one message is one
  packet of data; delivery is unacknowleged and unreliable; the consumer
  can specify quality of service parameters that the server can try to
  adhere to; lower-priority messages may be discarded in favour of high
  priority messages.


  <field name = "consume rate" type = "long">
    transfer rate in octets/second
    <doc>
      Specifies a desired transfer rate in octets per second. This is
      usually determined by the application that uses the streaming
      data.  A value of zero means "no limit", i.e. as rapidly as
      possible.
    </doc>
    <doc name = "rule">
      The server MAY ignore the prefetch values and consume rates,

    the queue was declared as private, and ideally, impose no limit
    except as defined by available resources.
  </doc>
  <doc name = "rule">
    Streaming applications SHOULD use different channels to select
    different streaming resolutions. AMQP makes no provision for
    filtering and/or transforming streams except on the basis of
    priority-based selective delivery of individual messages.
  </doc>
  <chassis name = "server" implement = "MUST" />
  <response name = "consume-ok" />

view all matches for this distribution

Net-API-Telegram

3 results

lib/Net/API/Telegram.pm view on Meta::CPAN


This parameter type is Integer and is optional.

If the message is a reply, ID of the original message

=item I<supports_streaming>

This parameter type is Boolean and is optional.

Pass True, if the uploaded video is suitable for streaming

=item I<thumb>

This parameter type is one of the following L<InputFile> or String and is optional.
Thumbnail of the file sent; can be ignored if thumbnail generation for the file is supported server-side. The thumbnail should be in JPEG format and less than 200 kB in size. A thumbnailâ€˜s width and height should not exceed 320. Ignored if the file...

view all matches for this distribution

Net-Amazon-EMR

1 match

lib/Net/Amazon/EMR.pm view on Meta::CPAN

  $emr->add_job_flow_steps(JobFlowId => $job_id,
                           Steps => [{
            ActionOnFailure => 'CANCEL_AND_WAIT',
            Name => "Example",
            HadoopJarStep => { 
              Jar => '/home/hadoop/contrib/streaming/hadoop-streaming.jar',
              Args => [ '-input', 's3://my-bucket/my-input',
                        '-output', 's3://my-bucket/my-output',
                        '-mapper', '/path/to/mapper-script',
                        '-reducer', '/path/to/reducer-script',
                      ],

lib/Net/Amazon/EMR.pm view on Meta::CPAN


=back

=head2 Mappers and Reducers

Assuming the reader is familiar with the basic principles of map-reduce, in terms of implementation in Perl with hadoop-streaming.jar, a mapper/reducer is simply a script that reads from STDIN and writes to STDOUT, typically line by line using a tab-...

    while (my $line = <>) {
      chomp $line;
      my ($key, $value) = split(/\t/, @line);
      ... do something with key and value
      print "$newkey\t$newvalue\n";
    }

Scripts can be uploaded to S3 using the web interface, or placed in the bootstrap bundle described above, or uploaded to the master instance using scp and distributed using the hadoop-streaming.jar -file option, or no doubt by many other mechanisms. ...

  Args => [ '-mapper', '"perl -e MyClass->new->mapper"', ... ]

=head1 AUTHOR

view all matches for this distribution

Net-Amazon-Glacier

1 match

lib/Net/Amazon/Glacier.pm view on Meta::CPAN

$tree_hash_array_ref must be an ordered list (same order as final assembled online
archive, as opposed to upload order) of partial tree hashes as returned by
multipart_upload_upload_part

$archive_size is provided at completion to check all parts make up an archive an
not before hand to allow for archive streaming a.k.a. upload archives of unknown
size. Beware of dead ends when choosing part size. Use
calculate_multipart_upload_partsize to select a part size that will work.

Returns an archive id that can be used to request a job to retrieve the archive
at a later time on success and 0 on failure.

view all matches for this distribution

Net-Amazon-HadoopEC2

1 match

lib/Net/Amazon/HadoopEC2/Cluster.pm view on Meta::CPAN

            -file reduce.pl
        )
    );
    my $result = $cluster->execute(
        {
            command => "$hadoop jar $streaming $option",
        }
    );


=head1 DESCRIPTION

view all matches for this distribution

Net-Async-AMQP

1 match

	(thanks to snappy for reporting + providing a test case for tracing).

0.028     2015-04-15 23:31:34+01:00 Europe/London
	Features:
	* Supports messages which have been split into multiple frames - currently
	there's no streaming support, but this should now handle arbitrarily-large
	messages as long as you have the memory available.

	Bugs fixed:
	* Better channel close detection and handling - we now also record when
	a ::Channel instance has been closed, so we know to report an error if any

view all matches for this distribution

Net-Async-FastCGI

7 results

lib/Net/Async/FastCGI.pm view on Meta::CPAN

Sets the default encoding used by all new requests. If not supplied then
C<UTF-8> will apply.

=item stream_stdin => BOOL

If true, requests will expect to handling streaming of stdin data. In this
mode, the C<on_request> event handler will be invoked once parameters for a
new request have been received, even if the stdin stream is not yet complete.

=back

view all matches for this distribution

Net-Async-HTTP-Server

6 results

lib/Net/Async/HTTP/Server.pm view on Meta::CPAN


Don't use L<HTTP::Message> objects as underlying implementation

=item *

Consider how to do streaming request inbound

=item *

Lots more testing

view all matches for this distribution

Net-Async-HTTP

3 results

           the same connection initially (RT66189)
         * When serialising a request, handle a full protocol://authority URI
           by splitting protocol/authority parts out of it

0.11    BUGFIXES:
         * Fix stalling t/12request-streaming.t test script that causes lots
           of FAILs at test time

0.10    CHANGES:
         * Support streaming of request body content
         * Support HTTP::Cookies object as a cookie jar
         * Allow proxy_host and proxy_port as ->configure parameters, to set
           defaults for requests

0.09    CHANGES:
         * Use IO::Async::Protocol->connect from 0.34

0.08    CHANGES:
         * Support streaming of response body content
         * Support SSL if IO::Async::SSL is installed

0.07    CHANGES:
         * base on IO::Async::Protocol::Stream

view all matches for this distribution

Net-Async-Pusher

3 results

lib/Net/Async/Pusher.pm view on Meta::CPAN


use parent qw(IO::Async::Notifier);

=head1 NAME

Net::Async::Pusher - support for pusher.com streaming event API

=head1 SYNOPSIS

 #!/usr/bin/env perl
 use strict;

view all matches for this distribution

Net-Async-Spotify

1 match

lib/Net/Async/Spotify/Scope.pm view on Meta::CPAN

use Exporter 'import';

our @EXPORT_OK = qw(scopes images listening_history spotify_connect playback playlists follow library users);
our %EXPORT_TAGS = ( all => \@EXPORT_OK );

my %scopes = map { $_ =~ s/-/_/gr => $_  } qw(ugc-image-upload user-read-recently-played user-read-playback-state user-top-read app-remote-control playlist-modify-public user-modify-playback-state playlist-modify-private user-follow-modify user-read-...

# TODO: Add support for endpoints allowed for each Scope.

=head1 METHODS

lib/Net/Async/Spotify/Scope.pm view on Meta::CPAN


Returns list of Spotify Scopes for Playback

=cut

sub playback { @scopes{qw(app_remote_control streaming)} }

=head2 playlists

Returns list of Spotify Scopes for Playlists

view all matches for this distribution

Net-Async-Webservice-S3

1 match

lib/Net/Async/Webservice/S3.pm view on Meta::CPAN


   my $if_match = $args{if_match};
   my $byte_range = $args{byte_range};

   # TODO: This doesn't handle retries correctly
   # But that said neither does the rest of this module, wrt: on_chunk streaming

   my $on_chunk = delete $args{on_chunk};

   my $header;
   my $head_future = $self->loop->new_future;

view all matches for this distribution

Net-Camera-Edimax-IC1500

1 match

lib/Net/Camera/Edimax/IC1500.pm view on Meta::CPAN


Returns the device's MAC address.

=item statusVideoPort

Returns the TCP port used by the video streaming applet.

=item statusHTTPPort

Returns the TCP port used for the web front end.

view all matches for this distribution

Net-DAAP-Server-MythTV

1 match

lib/Net/DAAP/Server/MythTV.pm view on Meta::CPAN

	$sth->execute($intid);

	my ($filename) = $sth->fetchrow_array;
	open $response->{handle}, '<', $filename;

	$response->streaming(1);
}

__END__

=head1 NAME

view all matches for this distribution

Net-Docker

5 results

lib/Net/Docker.pm view on Meta::CPAN

    my $url = $self->_uri('/containers/'.$container.'/attach');
    my $res = $self->ua->post($url, \%params);
    return $res->content;
}

sub streaming_logs {
    my ($self, $container, %options) = @_;

    *STDOUT->autoflush(1);

    my $input  = delete $options{in_fh};

lib/Net/Docker.pm view on Meta::CPAN

    );

    say $id;
    $api->start($id);

    my $cv = $api->streaming_logs($id,
        stream => 1, logs   => 1,
        stdin  => 1, stderr => 1, stdout => 1,
        in_fh  => \*STDIN, out_fh => \*STDOUT,
    );
    $cv->recv;

view all matches for this distribution

Net-Dropbear

1 match

dropbear/libtomcrypt/doc/crypt.tex view on Meta::CPAN

The \textit{header} data is meant to be meta--data associated with a stream that isn't private (e.g., protocol messages).  It can
be added at anytime during an EAX stream, and is part of the authentication tag.  That is, changes in the meta-data can be detected by changes in the output tag.

The mode can then process plaintext producing ciphertext as well as compute a partial checksum.  The actual checksum
called a \textit{tag} is only emitted when the message is finished.  In the interim, the user can process any arbitrary
sized message block to send to the recipient as ciphertext.  This makes the EAX mode especially suited for streaming modes
of operation.

The mode is initialized with the following function.
\index{eax\_init()}
\begin{verbatim}

dropbear/libtomcrypt/doc/crypt.tex view on Meta::CPAN

message of length \textit{headerlen} octets.

When this function completes, the \textit{eax} state will be initialized such that you can now either have data decrypted or
encrypted in EAX mode.  Note: if \textit{headerlen} is zero you may pass \textit{header} as \textbf{NULL} to indicate there is no initial header data.

To encrypt or decrypt data in a streaming mode use the following.
\index{eax\_encrypt()} \index{eax\_decrypt()}
\begin{verbatim}
int eax_encrypt(          eax_state *eax,
                const unsigned char *pt,
                      unsigned char *ct,

dropbear/libtomcrypt/doc/crypt.tex view on Meta::CPAN

}
\end{verbatim}
\end{small}

\mysection{GCM Mode}
Galois counter mode is an IEEE proposal for authenticated encryption (also it is a planned NIST standard).  Like EAX and OCB mode, it can be used in a streaming capacity
however, unlike EAX it cannot accept \textit{additional authentication data} (meta--data) after plaintext has been processed.  This mode also only works with
block ciphers with a 16--byte block.

A GCM stream is meant to be processed in three modes, one after another.  First, the initialization vector (per session) data is processed.  This should be
unique to every session.  Next, the the optional additional authentication data is processed, and finally the plaintext (or ciphertext depending on the direction).

view all matches for this distribution

Net-Etcd

6 results

lib/Net/Etcd.pm view on Meta::CPAN

    my @users = $range->all

    # delete single key
    $etcd->deleterange({ key => 'test0' });

    # watch key range, streaming.
    $watch = $etcd->watch( { key => 'foo', range_end => 'fop'}, sub {
        my ($result) =  @_;
        print STDERR Dumper($result);
    })->create;

view all matches for this distribution

Net-Fastly

1 match

    * Add mapping from backends to directors and directors to origins

0.8 2011-11-03

    * Add list_* to all objects
    * Add Healthchecks and Syslog endpoint streaming

0.7 2011-11-02

    * Fix stupid bug in fastly_upload_vcl

view all matches for this distribution

Net-Flowdock-Stream

1 match

lib/Net/Flowdock/Stream.pm view on Meta::CPAN

      }
  }

=head1 DESCRIPTION

This module implements the streaming api for
L<Flowdock|https://www.flowdock.com/>. It provides a non-blocking method which
you can call to get the next available event in the stream. You can then
integrate this method into your existing event-driven app.

=head1 ATTRIBUTES

view all matches for this distribution

Net-FullAuto

10 results

lib/Net/FullAuto/FA_Core.pm view on Meta::CPAN

   spl => 'application/futuresplash',
   spr => 'application/x-sprite',
   sprite => 'application/x-sprite',
   src => 'application/x-wais-source',
   ssi => 'text/x-server-parsed-html',
   ssm => 'application/streamingmedia',
   sst => 'application/vnd.ms-pki.certstore',
   step => 'application/step',
   stl => 'application/sla',
   #stl => 'application/vnd.ms-pki.stl',
   #stl => 'application/x-navistyle',

view all matches for this distribution

Net-IANA-Services

2 results

lib/Net/IANA/Services.pm view on Meta::CPAN


our $IANA_REGEX_PORTS = qr{\b(?<!-)(?:1(?:1(?:1(?:[234589]|0[345689]?|6[12345]?|7[12345]?|1[012]?)?|3(?:[034589]|2[01]?|19?|67?|71?)?|7(?:[0134678]|2[03]?|51?|96?)?|2(?:[23456789]|0[128]?|1?1)?|9(?:[01234578]|9[789]?|67?)?|0(?:[1234678]|0[01]?|9?5)?|...



our $IANA_REGEX_SERVICES = qr{\b(?<![-])(?:s(?:e(?:[pt]|r(?:v(?:e(?:r(?:view(?:-(?:asn?|icc|gf|rm)|dbms)|-find|graph|start|wsd2)|xec)|i(?:ce(?:-ctrl|meter|tags)|staitsm)|s(?:erv|tat))|comm-(?:scadmin|wlink)|ialgateway|aph)|c(?:-(?:t4net-(?:clt|srv)|p...



our $IANA_REGEX_PORTS_DCCP = qr{\b(?<!-)(?:1(?:02[12]|113)|500[45]|4556|6514|9)\b}i;  ## no critic(RegularExpressions)

lib/Net/IANA/Services.pm view on Meta::CPAN


our $IANA_REGEX_SERVICES_SCTP = qr{\b(?<![-])(?:a(?:sap-sctp(?:-tls)?|(?:hs|mq)p|25-fap-fgw|urora|ds-c)|s(?:i(?:mco|ps?)|(?:bc|gs)ap|1-control|mbdirect|sh|ua)|i(?:u(?:hsctpassoc|a)|tu-bicc-stc|pfixs?)|m(?:2(?:[pu]a|ap)|3(?:ap|ua)|egaco-h248)|wme(?:re...



our $IANA_REGEX_SERVICES_TCP = qr{\b(?<![-])(?:s(?:e(?:[pt]|r(?:v(?:e(?:r(?:view(?:-(?:asn?|icc|gf|rm)|dbms)|-find|graph|start|wsd2)|xec)|i(?:ce(?:-ctrl|meter|tags)|staitsm)|stat)|comm-(?:scadmin|wlink)|ialgateway|aph)|c(?:-(?:t4net-(?:clt|srv)|pc2fa...



our $IANA_REGEX_SERVICES_UDP = qr{\b(?<![-])(?:s(?:u(?:[am]|n(?:-(?:s(?:r-(?:iiop(?:-aut|s)?|https?|jm[sx]|admin)|ea-port)|as-(?:j(?:mxrmi|pda)|iiops(?:-ca)?|nodeagt)|user-https|mc-grp|dr|lm)|c(?:acao-(?:(?:jmx|sn)mp|websvc|csa|rmi)|luster(?:geo|mgr)...




####################

view all matches for this distribution

Net-IMP-HTTP

5 results

lib/Net/IMP/HTTP.pm view on Meta::CPAN

our @EXPORT;

# create and export NET_IMP_HTTP* constants
push @EXPORT, IMP_DATA( 'http',
    'header'     => +1,
    'body'       => -2, # message body: streaming
    'chkhdr'     => +3,
    'chktrailer' => +4,
    'data'       => -5, # encapsulated data (websocket etc): streaming
    'junk'       => -6, # junk data (leading empty lines..): streaming
);

push @EXPORT, IMP_DATA( 'httprq[http+10]',
    'header'     => +1,
    'content'    => -2, # unchunked, uncompressed content: streaming
    'data'       => -3, # encapsulated data (websocket etc): streaming
);


__END__

view all matches for this distribution

Net-IMP

8 results

our %EXPORT_TAGS = ( log => \@log_levels );

# data types/protocols
# These two are the basic types, more application specific types might
# be defined somewhere else and be mapped to a number within supported_dtypes.
# The only important thing is, that streaming data should be <0, while
# packetized data (like HTTP header or UDP datagrams) should be > 0
# If no explicit type is given in sub data, it will assume IMP_DATA_STREAM.
use constant IMP_DATA_STREAM  => dualvar(-1,'imp.data.stream');
use constant IMP_DATA_PACKET  => dualvar(+1,'imp.data.packet');

    package Net::IMP::HTTP;
    use Net::IMP 'IMP_DATA';
    use Exporter 'import';
    our @EXPORT = IMP_DATA('http',
	'header' => +1,   # packet type
	'body'   => -2,   # streaming type
	...
    );

=head1 DESCRIPTION


=over 4

=item IMP_DATA_STREAM (-1)

This is for generic streaming data, e.g. chunks from these datatypes can be
concatenated and analyzed together, parts can be replaced etc.

=item IMP_DATA_PACKET (+1)

This is for generic packetized data, where each chunk (e.g. call to C<data>)


=back

All other data types are considered either subtypes of IMP_DATA_PACKET
(value >0) or of IMP_DATA_STREAM (value<0) and share their restrictions.
Also only streaming data of the same type can be concatenated and
analyzed together.

Results will be delivered through the callback or via C<poll_results>.

=item $analyzer->poll_results => @results

The function C<IMP_DATA> is provided to simplify definition of new data types,
for example:

    our @EXPORT = IMP_DATA('http',
	'header'  => +1,   # packet type
	'body'    => -2,   # streaming type
	...
    );
    push @EXPORT = IMP_DATA('httprq[http+10]',
	'header'  => +1,   # packet type
	'content' => -2,   # streaming type
	...
    );

This call of IMP_DATA is equivalent to the following perl declaration:

view all matches for this distribution

Net-Icecast-Source

2 results

lib/Net/Icecast/Source.pm view on Meta::CPAN


######################

=head1 NAME

Net::Icecast::Source - Icecast streaming source

=head1 SYNOPSIS

	use Net::Icecast::Source;
	my $source = new Net::Icecast::Source(

lib/Net/Icecast/Source.pm view on Meta::CPAN

			aim => 'lindenstacker',
			url => 'http://icecast.org',
		},
	);

	# attempt to connect to the streaming server
	$source->connect
		or die "Unable to connect to server: $!\n";
		
	# attempt to log in to the specified mountpoint
	$source->login

view all matches for this distribution

Net-NATS-Streaming-Client

1 match

lib/Net/NATS/Streaming/Client.pm view on Meta::CPAN

  # Close stream
  $client->close_stream();

=head1 REPOSITORY

L<https://github.com/sergeykolychev/perl-nats-streaming>

=head1 SEE ALSO

L<https://github.com/carwynmoore/perl-nats>
Net::NATS::Client

view all matches for this distribution

Net-NATS-Streaming-PB

4 results