streaming results from the CPAN

lib/POE/Component/Amazon/S3.pm view on Meta::CPAN

    
    $params{libxml} = XML::LibXML->new;
    
    my $self = bless \%params, $class;
    
    # A non-streaming HTTP client for most requests
    POE::Component::Client::HTTP->spawn(
        Agent   => 'POE-Component-Amazon-S3/' . $VERSION,
        Alias   => 'ua',
        Timeout => 30,
    );
    
    # A streaming HTTP client for downloads
    POE::Component::Client::HTTP->spawn(
        Agent     => 'POE-Component-Amazon-S3/' . $VERSION,
        Alias     => 'ua-streaming',
        Timeout   => 30,
        Streaming => $BLOCK_SIZE,
    );
    
    POE::Session->create(

lib/POE/Component/Amazon/S3.pm view on Meta::CPAN

sub shutdown {
    my ( $kernel, $self ) = @_[ KERNEL, OBJECT ];
    
    # Shut down our HTTP clients
    $kernel->post( ua => 'shutdown' );
    $kernel->post( 'ua-streaming' => 'shutdown' );
    
    $kernel->alias_remove( $self->{alias} || 'amazon-s3' );
}

### Bucket methods

lib/POE/Component/Amazon/S3.pm view on Meta::CPAN

        event  => $event,
        file   => $file,
        pass   => $conf->{pass} || [],
    };

    $kernel->post( 'ua-streaming' => request => get_key_done => $request, $pass );
}

sub get_key_done {
    my ( $kernel, $self, $req, $res ) = @_[ KERNEL, OBJECT, ARG0, ARG1 ];

view all matches for this distribution

POE-Component-BlogCloud

5 results

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

1;
__END__

=head1 NAME

POE::Component::BlogCloud - Client interface to blo.gs streaming cloud server

=head1 SYNOPSIS

    use POE qw( Component::BlogCloud );
    POE::Component::BlogCloud->spawn(

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

    );

=head1 DESCRIPTION

I<POE::Component::BlogCloud> is a client interface to the I<blo.gs>
streaming cloud server, described at I<http://blo.gs/cloud.php>. It's
built using the L<POE> framework for Perl, allowing you to build an
event-based application that receives weblog updates, then acts upon them.

=head1 USAGE

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


=over 4

=item * ReceivedUpdate

The callback to execute when an update from the streaming server is
received. ARG0 contains a I<POE::Component::BlogCloud::Update> that
represents the update information.

This argument is required.

=item * AutoReconnect

If the client is disconnected from the streaming server because of an error,
it can be told to automatically try to reconnect by setting I<AutoReconnect>
to C<1>.

This argument is optional, and if not specified defaults to C<0>, meaning
that the client will not automatically reconnect.

=item * RemoteAddress

The address of the streaming server to connect to.

This argument is optional, and if not specified defaults to C<ping.blo.gs>.

=item * RemotePort

The port where the streaming server is running.

This argument is optional, and if not specified defaults to C<9999>.

=back

=head1 CAVEATS

The specification for the streaming server indicates that gzip compression
will be turned on at some point, at which point an update to this module
will be needed.

In addition, the blo.gs server does sometimes seem to get "stuck" and stop
sending updates, which will be indicated by the client hanging waiting

view all matches for this distribution

POE-Component-CD-Rip

1 match

Rip.pm view on Meta::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

POE

5 results

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

C<ClientFlushed> exposes POE::Wheel::ReadWrite's C<FlushedEvent> as a
callback.  It is called whenever the client's output buffer has been
fully flushed to the client socket.  At this point it's safe to shut
down the socket without losing data.

C<ClientFlushed> is useful for streaming servers, where a "flushed"
event signals the need to send more data.

  ClientFlushed => sub {
    my $data_source = $_[HEAP]{file_handle};
    my $read_count = sysread($data_source, my $buffer = "", 65536);

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