view release on metacpan or  search on metacpan

violite.h  view on Meta::CPAN

int	vio_blocking(Vio *vio, my_bool onoff, my_bool *old_mode);
my_bool	vio_is_blocking(Vio *vio);
/* setsockopt TCP_NODELAY at IPPROTO_TCP level, when possible */
int	vio_fastsend(Vio *vio);
/* setsockopt SO_KEEPALIVE at SOL_SOCKET level, when possible */
int	vio_keepalive(Vio *vio, my_bool	onoff);
/* Whenever we should retry the last read/write operation. */
my_bool	vio_should_retry(Vio *vio);
/* Check that operation was timed out */
my_bool	vio_was_interrupted(Vio *vio);
/* Short text description of the socket for those, who are curious.. */

violite.h  view on Meta::CPAN

#define vio_write(vio, buf, size)               ((vio)->write)(vio, buf, size)
#define vio_blocking(vio, set_blocking_mode, old_mode)\
 	(vio)->vioblocking(vio, set_blocking_mode, old_mode)
#define vio_is_blocking(vio) 			(vio)->is_blocking(vio)
#define vio_fastsend(vio)			(vio)->fastsend(vio)
#define vio_keepalive(vio, set_keep_alive)	(vio)->viokeepalive(vio, set_keep_alive)
#define vio_should_retry(vio) 			(vio)->should_retry(vio)
#define vio_was_interrupted(vio) 		(vio)->was_interrupted(vio)
#define vio_close(vio)				((vio)->vioclose)(vio)
#define vio_peer_addr(vio, buf, prt)		(vio)->peer_addr(vio, buf, prt)
#define vio_in_addr(vio, in)			(vio)->in_addr(vio, in)

violite.h  view on Meta::CPAN

  size_t  (*read)(Vio*, uchar *, size_t);
  size_t  (*write)(Vio*, const uchar *, size_t);
  int     (*timeout)(Vio*, uint, my_bool);
  int     (*vioblocking)(Vio*, my_bool, my_bool *);
  my_bool (*is_blocking)(Vio*);
  int     (*viokeepalive)(Vio*, my_bool);
  int     (*fastsend)(Vio*);
  my_bool (*peer_addr)(Vio*, char *, uint16*, size_t);
  void    (*in_addr)(Vio*, struct sockaddr_storage*);
  my_bool (*should_retry)(Vio*);
  my_bool (*was_timeout)(Vio*);

violite.h  view on Meta::CPAN

  int     (*vioerrno)(Vio*);
  xssize_t (*read)(Vio*, xgptr, xsize_t);
  xssize_t (*write)(Vio*, cxgptr, xsize_t);
  int     (*vioblocking)(Vio*, my_bool, my_bool *);
  my_bool (*is_blocking)(Vio*);
  int     (*viokeepalive)(Vio*, my_bool);
  int     (*fastsend)(Vio*);
  my_bool (*peer_addr)(Vio*, char *, uint16*);
  void    (*in_addr)(Vio*, struct in_addr*);
  my_bool (*should_retry)(Vio*);
  my_bool (*was_interrupted)(Vio*);

violite.h  view on Meta::CPAN

  int     (*vioerrno)(Vio*);
  size_t  (*read)(Vio*, unsigned char *, size_t);
  size_t  (*write)(Vio*, const unsigned char *, size_t);
  int     (*vioblocking)(Vio*, my_bool, my_bool *);
  my_bool (*is_blocking)(Vio*);
  int     (*viokeepalive)(Vio*, my_bool);
  int     (*fastsend)(Vio*);
  my_bool (*peer_addr)(Vio*, char *, uint16*, size_t);
  void    (*in_addr)(Vio*, struct sockaddr_storage*);
  my_bool (*should_retry)(Vio*);
  my_bool (*was_interrupted)(Vio*);

violite.h  view on Meta::CPAN

  void    (*viodelete)(Vio*);
  int     (*vioerrno)(Vio*);
  size_t  (*read)(Vio*, uchar *, size_t);
  size_t  (*write)(Vio*, const uchar *, size_t);
  int     (*timeout)(Vio*, uint, my_bool);
  int     (*viokeepalive)(Vio*, my_bool);
  int     (*fastsend)(Vio*);
  my_bool (*peer_addr)(Vio*, char *, uint16*, size_t);
  void    (*in_addr)(Vio*, struct sockaddr_storage*);
  my_bool (*should_retry)(Vio*);
  my_bool (*was_timeout)(Vio*);

 view release on metacpan or  search on metacpan

lib/Courier/Filter.pm  view on Meta::CPAN

    
    if (-e $socket_name) {
        -S $socket_name
            or throw Courier::Error("$socket_name already exists but is not a socket");
        
        # Try to connect to socket to see if it is alive or
        # if it is left over from a crashed Courier::Filter:
        my $test_socket = IO::Socket::UNIX->new( Peer => $socket_name );
        
        not defined($test_socket)
            or throw Courier::Error("Live socket $socket_name found -- is Courier::Filter already running?");

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

2.32 2011-08-11 19:06:38
	- fix a bug in the initial whitespace accumulation.

2.31 2011-07-27 17:53:05
	- don't accumulate initial whitespace in the incremental buffer
          (this can be useful to allow whitespace-keepalive on a tcp
          connection without triggering the max_size limit).
	- properly croak on some invalid inputs that are not strings
          (e.g. undef) when trying to decode a json text (reported
          and analyzed by Goro Fuji).

 view release on metacpan or  search on metacpan

lib/Crop/Object/Collection.pm  view on Meta::CPAN

=begin nd
Method: Cleanup ( )
	Remove all the items from Collection.
	
	Still alive items in the warehouse.
Returns:
	$self
=cut
sub Cleanup {
	my $self = shift;

 view release on metacpan or  search on metacpan

lib/Crop/Object/Collection.pm  view on Meta::CPAN

=begin nd
Method: Cleanup ( )
	Remove all the items from Collection.
	
	Still alive items in the warehouse.
Returns:
	$self
=cut
sub Cleanup {
	my $self = shift;

 view release on metacpan or  search on metacpan

lib/Crypt/Bear/SSL/Engine.pm  view on Meta::CPAN

This pushed (encrypted) records received from the socket into the buffer, and returns the (decrypted) applicatoin data.

=head2 pull_send($flush = false)

This will pull any pending records to be send to the other side. This is primarily useful around opening and closing connections when data can't be send yet. If C<$flush> is true, it will create an empty record if no pending data is available, this c...

=head2 send_ready()

This returns true if the connection is ready for application data to be pushed in to be sent to the other side. This is useful to know when you're done connecting. Note that this can also be false when the send buffer is full, sp so it's not very use...

 view release on metacpan or  search on metacpan

lib/Crypt/Diceware/Wordlist/Beale.pm  view on Meta::CPAN

  ag again agate age aged agenda agent ages agile aging aglow agnes agnew ago
  agony agree ah aha ahab ahead ahem ahmed ahoy ai aid aide aided ail aim
  aimed aims ain't air airman airway airy aisle aj ajar ajax ak aka akers
  akin akqj akron al alan alarm alas alaska album alden ale alec aleck alert
  alex alexa alexei algae alger ali alias alibi alice alien alight align
  alike alive alkali all allah allan allen alley allied allot allow alloy
  allure ally alma almost alms aloft aloha alone along aloof aloud alp alpha
  alps also alsop altar alter altho alto alum alumni alvin alyx am am/fm
  amass amaze amber amble ambush amen amend ames amid amigo amino amish amiss
  amity ammo amok among amos amour amp ampere ample amply amps amulet amuse
  amy an anal anchor and andes andre andrew andy anew angel angelo anger

 view release on metacpan or  search on metacpan

lib/Crypt/HSXKPasswd/Dictionary/FR.pm  view on Meta::CPAN

    'balisée',
    'balisées',
    'balisés',
    'balivage',
    'balivages',
    'baliveau',
    'baliveaux',
    'baliverne',
    'balivernes',
    'balkanique',
    'balkaniques',
    'balkanisa',
    'balkanisai',
    'balkanisais',

lib/Crypt/HSXKPasswd/Dictionary/FR.pm  view on Meta::CPAN

    'salivasses',
    'salivassiez',
    'salivassions',
    'salivation',
    'salivations',
    'salive',
    'salivent',
    'saliver',
    'salivera',
    'saliverai',
    'saliveraient',
    'saliverais',
    'saliverait',
    'saliveras',
    'saliverez',
    'saliveriez',
    'saliverions',
    'saliverons',
    'saliveront',
    'salives',
    'salivez',
    'saliviez',
    'salivions',
    'salivons',
    'salivâmes',
    'salivât',

 view release on metacpan or  search on metacpan

matrixssl-1-8-6-open/examples/httpsClient.c  view on Meta::CPAN

	conn = NULL;
/*
	First (optional) argument is ip address to connect to (port is hardcoded)
	Second (optional) argument is number of iterations to perform
	Third (optional) argument is number of keepalive HTTP requests
	Fourth (optional) argument is cipher suite number to use (0 for any)
*/
	ip = HTTPS_IP;
	iterations = ITERATIONS;
	requests = REQUESTS;

 view release on metacpan or  search on metacpan

lib/Net/NSS/SSL.pm  view on Meta::CPAN

If true then create the socket, import it into SSL, set the specfied options but don't connect. Defaults to false if omitted.

=item KeepAlive : boolean

Periodically test whether connection is still alive. Default to false if omitted.

=item Blocking : boolean

Blocking or non-blocking I/O. Default to 1 if omitted or what the class method C<blocking> returns if such exists.

lib/Net/NSS/SSL.pm  view on Meta::CPAN

=over 4

=item KeepAlive : boolean

Periodically test whether connection is still alive.

=item NoDelay : boolean

Disable Nagle algorithm. Don't delay send to coalesce packets.

 view release on metacpan or  search on metacpan

lib/Crypt/RSA/Errorhandler.pm  view on Meta::CPAN

    package Foo;

    use Crypt::RSA::Errorhandler;
    @ISA = qw(Crypt::RSA::Errorhandler);
    
    sub alive { 
        ..
        ..
        return 
        $self->error ("Awake, awake! Ring the alarum bell. \
                       Murther and treason!", $dagger) 

lib/Crypt/RSA/Errorhandler.pm  view on Meta::CPAN

    package main; 

    use Foo;
    my $foo = new Foo;
    $foo->alive($king) or print $foo->errstr(); 
        # prints "Awake, awake! ... "

=head1 DESCRIPTION 

Crypt::RSA::Errorhandler encapsulates the error handling mechanism used

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

	recommends 'Digest::SHA' => 0;
}

recommends 'Crypt::RIPEMD160'  => 0; # it's hip
recommends 'Digest::Whirlpool' => 0; # it's happenning
recommends 'Digest::MD5'       => 0; # it's still alive =(

recommends "Digest::HMAC" => 0;
recommends "Digest::CMAC" => 0;

license "MIT";

 view release on metacpan or  search on metacpan

lib/Crypt/XKCDCommon1949.pm  view on Meta::CPAN

our @words = (
"ability","able","aboard","about","above","accept","accident","according",
"account","accurate","acres","across","act","action","active","activity",
"actual","actually","add","addition","additional","adjective","adult","adventure",
"advice","affect","afraid","after","afternoon","again","against","age",
"ago","agree","ahead","aid","air","airplane","alike","alive",
"all","allow","almost","alone","along","aloud","alphabet","already",
"also","although","am","among","amount","ancient","angle","angry",
"animal","announced","another","answer","ants","any","anybody","anyone",
"anything","anyway","anywhere","apart","apartment","appearance","apple","applied",
"appropriate","are","area","arm","army","around","arrange","arrangement",

 view release on metacpan or  search on metacpan

lib/Crypt/XkcdPassword/Words/EN.pm  view on Meta::CPAN

drink
absolutely
how's
daddy
sweet
alive
paul
sense
meant
happens
david

 view release on metacpan or  search on metacpan

lib/Crypto/NanoRPC.pm  view on Meta::CPAN

    delegators => [ 'account' ],
    delegators_count => [ 'account' ],
    deterministic_key => [ 'seed', 'index' ],
    frontier_count => [],
    frontiers => [ 'account', 'count' ],
    keepalive => [ 'address', 'port' ],
    key_create => [],
    key_expand => [ 'key' ],
    ledger => [ 'account', 'count', [ 'representative', 'weight', 'pending', 'modified_since', 'sorting' ] ],
    node_id => [],
    node_id_delete => [],

lib/Crypto/NanoRPC.pm  view on Meta::CPAN

See L<https://docs.nano.org/commands/rpc-protocol/> for a list of RPC calls. This module implements the following RPCs:

=head2 Node RPCs

account_balance account_block_count account_get account_history account_info account_key account_representative account_weight accounts_balances accounts_frontiers accounts_pending active_difficulty available_supply block_account block_count block_co...

=head2 Wallet RPCs

account_create account_list account_move account_remove account_representative_set accounts_create password_change password_enter password_valid receive receive_minimum receive_minimum_set search_pending search_pending_all send wallet_add wallet_add_...

 view release on metacpan or  search on metacpan

lib/CtrlO/Crypt/XkcdPassword/Wordlist/eff_large.pm  view on Meta::CPAN

alibi
alienable
alienate
aliens
alike
alive
alkaline
alkalize
almanac
almighty
almost

 view release on metacpan or  search on metacpan

t/transaction.t  view on Meta::CPAN

	sub AUTOLOAD {}
}

# On some versions of perl, destroyers may unset $@; we're immune to it.
{
	my $expected_exceptions = qr/(?:the hills are alive|an error was encountered in your transaction)/;

	{
		local $@;
		eval {
			run_in_transaction {
				my $fake_dbh = bad::citizen->new;
				die 'the hills are alive';
			} db_handle => $stub_dbh, on_error => 'rollback';
		};

		like( $@, $expected_exceptions, 'if $@ is unintentionally unset on object destruction, we set a sensible default error' );
	}

	{
		local $@;
		run_in_transaction {
			my $fake_dbh = bad::citizen->new;
			die 'the hills are alive';
		} db_handle => $stub_dbh, on_error => 'continue';

		like( $@, $expected_exceptions, 'if $@ is unintentionally unset on object destruction, we set a sensible default error' );
	}
}

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.15    2015/08/11

      * Support for pagination through result sets
      * careful: Timestamps are now in msec accuracy instead of having them as floating points
      * Enable TCP keepalive on sockets

0.14    2015/05/19

      * Resolve an old bug where connecting to CQL3 might cause compilation errors
      * Fix an issue where the consistency ONE was treated as LOCAL_ONE

 view release on metacpan or  search on metacpan

lib/DBD/Crate.pm  view on Meta::CPAN

        my ($drh, $dburl, $user, $pass, $attr) = @_;
        my $UTF8 = defined $attr->{utf8} ?
                        $attr->{utf8} : 1;

        $JSON = JSON::MaybeXS->new({ utf8 => $UTF8 });
        $HTTP = HTTP::Tiny->new( keep_alive => 1 );

        my @addresses = ($dburl);
        my @addr;
        if ($dburl =~ s/^\[(.*?)\]$/$1/){
            @addresses = split ',', $dburl;

 view release on metacpan or  search on metacpan

tests/perld060_pingConnWithNormalDisconnect.pl  view on Meta::CPAN

}

print "Testing connection... ";
if( $dbh->ping )
{
  print "Error: connection appears to be alive\n";
}
else
{
  print "disconnected.\n";
}

 view release on metacpan or  search on metacpan

samples/dbi_3_connect.pl  view on Meta::CPAN

print "\n\nDisconnecting connection 1 ... ";
$dbh1->disconnect;
print "ok.\n\n";

print "Sent a ping to connection 1 to see if the connection is alive (this should fail).\n\n";
my $alive = $dbh1->ping();
print "ping ...";
($alive) ? print " still alive.\n\n" : print " connection dead.\n\n";


print "Try a second connection after the first has been closed (this should work) ... ";
my $dbh3 = DBI->connect(	$dsn, 
							'dtfadm', 
							'dtfadm', 
							{RaiseError => 1, AutoCommit => 0}
					   ) ||  die "Can't connect to database: " . DBI->errstr;
print "ok.\n\n";

print "Sent a ping to the second connection to see if connection is alive (this should work).\n\n";
$alive = $dbh3->ping();
print "ping ...";
($alive) ? print " still alive.\n\n" : print " connection dead.\n\n";

print "\nDisconnecting ... ";
$dbh3->disconnect;
print "ok.\n\n";

 view release on metacpan or  search on metacpan

lib/DBD/Informix/TestHarness.pm  view on Meta::CPAN

When it is called, memory_leak_test forks, and the parent process runs
the given subroutine with no arguments.
The subroutine will do the sequence of database operations which show
that there is a memory leak, or that the memory leak is fixed.
The child process checks that the parent is still alive, and runs the
C<ps> command to determine the size of the process.
The output of C<ps> is not parsed, so you have to run the test in a
verbose mode to see whether there is a memory leak or not.

    &memory_leak_test(\&test_subroutine);

 view release on metacpan or  search on metacpan

lib/DBD/JDBC.pm  view on Meta::CPAN

                             $dbh->FETCH('jdbc_socket'), $dbh->FETCH('jdbc_ber'),
                             [ROLLBACK_REQ => 0],
                             [ROLLBACK_RESP => \$resp]);
    }

    # Confirms that the server is alive and that this particular
    # (JDBC) connection has not been closed.
    #
    # JDBC: Connection.isClosed
    sub ping {
        my ($dbh) = shift;

 view release on metacpan or  search on metacpan

SQLAnywhere.pm  view on Meta::CPAN

	# Strictly speaking, the prepare() could fail due to an error
	# reported from the server (eg. if we exceed the prepared statement
	# limit) but we don't have access to the ping facility through DBCAPI
	# so this is usually a valid test.
	my $rv = eval { $dbh->prepare( "select 1" ); };
	my $alive = ( defined( $rv ) ? 1 : 0 );

	# Suppress the error for ping() -- it should just return a boolean without reporting error
	$dbh->set_err( undef, undef );

	return( $alive );
    }


# Use the DBI-provided quote routine
#    sub quote {

 view release on metacpan or  search on metacpan

lib/DBD/Safe.pm  view on Meta::CPAN

Connection is checked on each query. This can double your request execution time if all your requests are fast and network latency of your database is big enough.

Statement objects are not safe. Once you've prepared the statement, it won't reconnect to the database transparently.

There are no retries. If the request fails, it fails. This module just check that DB is alive *before* it tries to execute the statement. (Custom, per-query policies support is planned for the future releases).

=head1 SEE ALSO

L<http://github.com/tadam/DBD-Safe>,
L<DBIx::Connector>, L<DBIx::HA>, L<DBIx::DWIW>.

 view release on metacpan or  search on metacpan

Sybase.pm  view on Meta::CPAN

Tell DBD::Sybase what the server type is. Defaults to ASE. Setting it to 
something else will prevent certain actions (such as setting options, 
fetching the ASE version via @@version, etc.) and avoid spurious errors.

=item tds_keepalive

Set this to 1 to tell OpenClient to enable the KEEP_ALIVE attribute on the 
connection. Default 1.

=back

 view release on metacpan or  search on metacpan

lib/DBD/Wire10.pm  view on Meta::CPAN

=head4 reconnect

Makes sure that there is a connection to the database server.  If there is no connection, and the attempt to reconnect fails, an error is reported via the standard DBI error reporting mechanism.

Notice that the timeout when calling this method is in a sense doubled.  reconnect() first performs a ping() if the connection seems to be alive.  If the ping fails after C<wire10_connect_timeout> seconds, then a new underlying connection is establis...

=head4 err

Contains an error code when an error has happened.  Always use RaiseError and eval {} to catch errors in production code.

 view release on metacpan or  search on metacpan

cci-src/src/cci/cci_handle_mng.c  view on Meta::CPAN

      start_time = time (NULL);
      for (i = 0; i < host_status_count; i++)
	{
	  ip_addr = host_status[i].host.ip_addr;
	  port = host_status[i].host.port;
	  if (!host_status[i].is_reachable && net_check_broker_alive (ip_addr, port, BROKER_HEALTH_CHECK_TIMEOUT))
	    {
	      hm_set_host_status_by_addr (ip_addr, port, true);
	    }
	}
      elapsed_time = time (NULL) - start_time;

 view release on metacpan or  search on metacpan

lib/DBI/Shell.pm  view on Meta::CPAN

sub do_ping {
    my ($sh, @args) = @_;
    return $sh->print_buffer_nop (
	"Connection "
	, $sh->{dbh}->ping() == '0' ? 'Is' : 'Is Not'
	, " alive\n" );
}

sub do_edit {
    my ($sh, @args) = @_;

 view release on metacpan or  search on metacpan

lib/DBD/DBM.pm  view on Meta::CPAN

    my $dver;
    my $dtype = $meta->{dbm_type};
    eval {
        $dver = $meta->{dbm_type}->VERSION();

        # *) when we're still alive here, everything went ok - no need to check for $@
        $dtype .= " ($dver)";
    };
    if ( $meta->{dbm_mldbm} )
    {
        $dtype .= ' + MLDBM';