view release on metacpan or  search on metacpan

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

      $Priv = [] unless ($Priv and ref($Priv) eq 'ARRAY');
      foreach my $item (@$Priv) {
        $Privileges{'mayAdmin'} = $JSON::true if $item->{"{$NS_CY}admin"};
        $Privileges{'mayWrite'} = $JSON::true if $item->{"{$NS_D}write-content"};
        $Privileges{'mayRead'} = $JSON::true if $item->{"{$NS_D}read"};
        $Privileges{'mayReadFreeBusy'} = $JSON::true if $item->{"{$NS_C}read-free-busy"};
      }

      my $CanSync;
      my $Report = $Propstat->{"{$NS_D}prop"}{"{$NS_D}supported-report-set"}{"{$NS_D}supported-report"};
      $Report = [] unless ($Report and ref($Report) eq 'ARRAY');

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

        );
        foreach my $item (@{$Acl->{"{$NS_D}grant"}{"{$NS_D}privilege"}}) {
          $ShareObject{'mayAdmin'} = $JSON::true if $item->{"{$NS_CY}admin"};
          $ShareObject{'mayWrite'} = $JSON::true if $item->{"{$NS_D}write-content"};
          $ShareObject{'mayRead'} = $JSON::true if $item->{"{$NS_D}read"};
          $ShareObject{'mayReadFreeBusy'} = $JSON::true if $item->{"{$NS_C}read-free-busy"};
        }

        push @ShareWith, \%ShareObject;
      }

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

  return $Events->[0];
}

=head2 $self->GetFreeBusy($calendarId, %Args)

Like 'GetEvents' but uses a free-busy-query and then generates
synthetic events out of the result.

Doesn't have a 'href' parameter, just the before/after range.

=cut

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

  # }}}

  my $Response = $Self->Request(
    'REPORT',
    "$calendarId/",
    x('C:free-busy-query', $Self->NS(),
      @Query,
    ),
    Depth => 1,
  );

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

  my @result;
  my @errors;
  my $now = DateTime->now();
  foreach my $item (@{$Data->{objects}[0]{objects}}) {
    next unless $item->{type} eq 'vfreebusy';
    foreach my $line (@{$item->{properties}{freebusy}}) {
      my ($Start, $End) = split '/', $line->{value};
      my ($StartTime, $IsAllDay) = $Self->_makeDateObj($Start, 'UTC', 'UTC');
      my $EndTime;
      if ($End =~ m/^[+-]?P/i) {
          my $Duration = eval { DateTime::Format::ICal->parse_duration(uc $End) }

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

        title => ($Args{name} // ''),
        isAllDay => ($IsAllDay ? $JSON::true : $JSON::false),
        updated => $now->iso8601(),
      };

      # Generate a uid that should remain the same for this freebusy entry
      $NewEvent->{uid} = _hexkey($NewEvent) . '-freebusyauto';
      $NewEvent->{isAllDay} =
        $NewEvent->{isAllDay} ? $JSON::true : $JSON::false;
      push @result, $NewEvent;
    }
  }

 view release on metacpan or  search on metacpan

lib/Net/Clacks/Client.pm  view on Meta::CPAN

    # otherwise spin forever when the server is alive but not consuming.
    $self->{stalledwritetimeout} = 30;

    # TCP connect timeout. Without this, a TCP connect to an unreachable host
    # waits for the kernel SYN-retransmit timeout (~75 s on Linux) before
    # giving up. Defaulted generously so a transiently-busy server (full
    # listen backlog, scheduler delays under load) or a slow link doesn't
    # produce false-positive failures. Unix-domain sockets are not affected —
    # connect there fails or succeeds immediately.
    $self->{connecttimeout} = 60;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.25  Thu Oct  2 13:39:49 PDT 2008
	add CPAN automated tester cutout if pcap lib is not installed

0.24  Mon Jan 14 11:48:04 PST 2008
	force timecheck every second, even if very busy
	so that old IP's will expire

0.23  Wed Apr 25 16:52:52 PDT 2007
	add redundant DNS name reporting to compensate for occasional
	missing rDNS entries for remote hosts

 view release on metacpan or  search on metacpan

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

	# if ($_LEVEL) { add to Pending } else { recv/send }

	$self->recv(0);	# Perform fast case unconditionally.
	# print "Queue size " . scalar(keys %{ $self->{Queue} });
	while (scalar(keys %{ $self->{Queue} }) > $self->{QueueSize}) {
		# I'm fairly sure this can't busy wait since it must
		# either time out an entry or receive an entry when called
		# with no arguments.
		$self->recv();
	}

 view release on metacpan or  search on metacpan

extra_docs/af-saa-0069.000.txt  view on Meta::CPAN

? Hierarchical naming structure (scalability)
? low latency of queries
? Toleration of temporary inconsistency, that is, that such 
inconsistency does not damage the information in ANS.
? The service may sometimes be transiently unavailability, for 
example, “a busy signal” 
 
 Other ANS requirements include:
 
? Independence between non-ATM network and transport layer 
protocols 

 view release on metacpan or  search on metacpan

t/query.t  view on Meta::CPAN

	  push @wmsg, $buffer;
	  push @who, $rsin;
	}
      }
      if ($wout && @wmsg) {			# if there is work
	unless ($woff) {			# if not busy
	  $wmsglen = $wmsglen[0];
	}
	if ($wlen = send($remotsock,$wmsg[0],0,$who[0])) {
	  $wmsglen -= $wlen;
	  $woff += $wlen;

 view release on metacpan or  search on metacpan

lib/Net/DNS/Multicast.pm  view on Meta::CPAN

	}
	return $select;
}


sub Net::DNS::Resolver::bgbusy {
	my ( $self, $select ) = @_;
	my ($handle) = ( $select->can_read(0), $select->handles );
	return Net::DNS::Resolver::Base::bgbusy( $self, $handle );
}


sub Net::DNS::Resolver::bgread {
	my ( $self, $select ) = @_;

 view release on metacpan or  search on metacpan

lib/Net/DNS/Native.pm  view on Meta::CPAN

requests will be queued until one of the threads will become free to process next request from the queue.

=item extra_thread => $bool

If pool option specified and $bool has true value will create temporary extra thread for each request that can't be handled by the
pool (when all workers in the pool are busy) instead of pushing it to the queue. This temporary thread will be finished immediatly
after it will process request.

=item notify_on_begin => $bool

Extra mechanizm to notify caller that resolving for some host started. This is usefull for those who uses thread pool without C<extra_thread>

lib/Net/DNS/Native.pm  view on Meta::CPAN

=head2 timedout($handle)

Mark resolving operation associated with this handle as timed out. This will not interrupt resolving operation (because there is no way to interrupt getaddrinfo(3) correctly),
but will automatically discard any results returned when resolving will be done. So, after C<timedout($handle)> you can forget about C<$handle> and
associated resolving operation. And don't need to call C<get_result($handle)> to destroy resources associated with this handle. Furthermore, if you are using thread pool
and all threads in pool are busy and C<extra_thread> option not specified, but 1 resolving operation from this pool marked as timed out and you'll add one more resolving operation,
this operation will not be queued. Instead of this 1 temporary extra thread will be created to process this operation. So you can think about C<timedout> like about real interrupter of
long running resolving operation. But you are warned how it really works. B<Note:> since 0.16 handles will be automatically marked as timedout during destruction, so you no need more to
call C<timedout($handle)> yourself, just lose last reference to this handle.

=head1 AUTHOR

 view release on metacpan or  search on metacpan

QueryID.pm  view on Meta::CPAN

$VERSION = do { my @r = (q$Revision: 0.02 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };

@EXPORT_OK = qw(
	id_get
	id_clr
	id_busy
);

sub DESTROY {};

=head1	NAME

QueryID.pm  view on Meta::CPAN

	http://en.wikipedia.org/wiki/DNS_cache_poisoning

  use Net::DNS::QueryID qw(
	id_get
	id_clr
	id_busy
  );

  $queryID = id_get();
  $result  = id_clr($queryID);
  $result  = id_busy($queryID);

=cut

my $idvec = '';
foreach(0..2047) {	# set 65536 long vector string to zero

QueryID.pm  view on Meta::CPAN

  return 0 unless vec($idvec,$_[0],1);
  vec($idvec,$_[0],1) = 0x0;
  return $_[0];
}

=item * $result  = id_busy($queryID);

  input:	Query ID
  returns:	true if Query ID is in the cache
		false if Query ID is not in the cache
		false if Query ID is out of range
		i.e. not 1 -165535

=cut

sub id_busy($) {
  return 0 if $_[0] < 1 or $_[0] > 65535;
  vec($idvec,$_[0],1);
}

sub _mode {

QueryID.pm  view on Meta::CPAN

=head1 EXPORTS_OK

	id_get
	id_clr
	id_busy

=head1 AUTHOR

Michael Robinton <michael@bizsystems.com>

 view release on metacpan or  search on metacpan

lib/Net/DNS/Resolver/DoH.pm  view on Meta::CPAN

}

#sub srcaddr { ## TODO

sub bgsend { die 'not implemented' }
sub bgbusy { die 'not implemented' }
sub bgread { die 'not implemented' }
sub bgisready { die 'not implemented' }
sub axfr { die 'not implemented' }

## TODO override methods not available via DoH

 view release on metacpan or  search on metacpan

lib/Net/DNS/Resolver/Unbound.pm  view on Meta::CPAN

}

sub nameserver { return &nameservers }


=head2 search, query, send, bgsend, bgbusy, bgread

See L<Net::DNS::Resolver>.

=cut

lib/Net/DNS/Resolver/Unbound.pm  view on Meta::CPAN

	$reply->print if $self->debug;
	return $reply;
}

sub bgbusy {
	my ( $self, $handle ) = @_;
	return unless $handle;
	return unless $handle->waiting;
	$self->{ub_ctx}->ub_process;
	eval { select( undef, undef, undef, 0.200 ) };		# avoid tight loop on bgbusy()
	return $handle->waiting;
}


=head2 option

 view release on metacpan or  search on metacpan

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

	my $res    = Net::DNS::Resolver->new;
	$res->udp_timeout(10);
	$res->tcp_timeout(20);
	my $socket = $res->bgsend( "www.example.com", "AAAA" );

	while ( $res->bgbusy($socket) ) {
		# do some work here whilst awaiting the response
		# ...and some more here
	}

	my $packet = $res->bgread($socket);

 view release on metacpan or  search on metacpan

MultiDaemon.pm  view on Meta::CPAN

	      }
	      elsif ($rip eq '2.0.0.127') {				# checkfor DNSBL test
		($msg) = _ansrbak($put,$id,1,$rip,$zone,$type,3600,A1272,$BLzone,$myip,'DNSBL test response to 127.0.0.2');
		$comment = 'just testing';
	      }
### NOTE, $now does not get updated very often if the host is busy processing in this routine, but at least every 5 minutes.... good enough
	      elsif (	$csize && 					# cacheing enabled
			exists $cache{$rip} &&				# item exists in cache
			($expires = $cache{$rip}->{expires}) > $now ) {	# cache not expired
		$cache{$rip}->{used} = $now;				# update last used time
		my $blist_0 = $cache{$rip}->{who};

MultiDaemon.pm  view on Meta::CPAN

	  }
	}
	last;
      }
    }
##################### TIMEOUT, do busywork #######################
    else {							# must be timeout
      my $prpshadow = $prp;
      $now = time;						# check various alarm status
      unless ($now < $next) {
	average($STATs);

 view release on metacpan or  search on metacpan

lib/Net/DirectConnect/clihub.pm  view on Meta::CPAN

        if ( $text =~
             /(?:Пожалуйста )?подождите (\d+) секунд перед следующим поиском\./i
          or $text =~ /(?:Please )?wait (\d+) seconds before next search\./i
          or $text eq 'Пожалуйста не используйте поиск так часто!'
          or $text eq "Please don't flood with searches!"
          or $text eq 'Sorry Hub is busy now, no search, try later..' )
        {
          $self->{'search_every'} += int( rand(5) + $1 || $self->{'search_every_min'} );
          $self->log( 'warn', "[$nick] oper: increase min interval => $self->{'search_every'}" );
          $self->search_retry();
        }

lib/Net/DirectConnect/clihub.pm  view on Meta::CPAN

      if ( !$self->{count_parse}{chatline} and $text =~ /PtokaX/i ) {
        #$self->log( 'dev', "[$nick] - probably hub bot" );
        $self->{'NickList'}{$nick}{'hubbot'} = 1;
      }
      $self->search_retry(),
        if $self->{'NickList'}->{$nick}{'oper'} and $text eq 'Sorry Hub is busy now, no search, try later..';
    },
    'welcome' => sub {
      my $self = shift if ref $_[0];
      my ( $nick, $text ) = $_[0] =~ /^(?:<|\* )(.+?)>? (.+)$/s;
      if ( !keys %{ $self->{'NickList'} } or !exists $self->{'NickList'}->{$nick} or $self->{'NickList'}->{$nick}{'oper'} ) {

 view release on metacpan or  search on metacpan

t/docker-api.t  view on Meta::CPAN

use Data::Dumper;

my $api = Net::Docker->new;
ok($api);

my @lines = $api->pull('busybox');
for (@lines) {
    ok(exists $_->{status});
}

my $version = $api->version;

t/docker-api.t  view on Meta::CPAN

my $info = $api->info;
ok(exists $info->{Containers});
ok(exists $info->{Images});

my $inspect = $api->inspect('busybox');
#is($inspect->{id}, 'a9eb172552348a9a49180694790b33a1097f546456d041b6e82e4d7716ddb721');
ok($inspect->{id});

done_testing();

 view release on metacpan or  search on metacpan

dropbear/MULTI  view on Meta::CPAN

========================

To compile for systems without much space (floppy distributions etc), you
can create a single binary. This will save disk space by avoiding repeated
code between the various parts.
If you are familiar with "busybox", it's the same principle.

To compile the multi-binary, first "make clean" (if you've compiled
previously), then

make PROGRAMS="programs you want here" MULTI=1

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

  For bug tracking, use the CPAN bug tracker at:

      https://rt.cpan.org/Dist/Display.html?Name=Net-Duo

  However, please be aware that I tend to be extremely busy and work
  projects often take priority.  I'll save your report and get to it as
  soon as I can, but it may take me a couple of months.

SOURCE REPOSITORY

 view release on metacpan or  search on metacpan

Gadu.pm  view on Meta::CPAN

sub set_available {
    my ($cl) = @_;
    $cl->change_status($Net::Gadu::STATUS_AVAIL); # GG_STATUS_AVAIL
}

sub set_busy {
    my ($cl) = @_;
    $cl->change_status($Net::Gadu::STATUS_BUSY); # GG_STATUS_BUSY
}

sub set_not_available {

Gadu.pm  view on Meta::CPAN

Wysyła wiadomość pod wskazany numer UIN.


=item $gg->set_available();

Ustawia status na dostepny. Podobne funkcje : set_busy(), set_invisible(), set_not_available(), change_status().


=item $gg->add_notify($uin)

    parametry:

 view release on metacpan or  search on metacpan

share/services_hashes_dump.yml  view on Meta::CPAN

  4989:
    - parallel
  499:
    - iso-ill
  4990:
    - busycal
  4991:
    - vrt
  4999:
    - hfcs-manager
  5:

share/services_hashes_dump.yml  view on Meta::CPAN

      - iso-ill
    udp:
      - iso-ill
  4990:
    tcp:
      - busycal
    udp:
      - busycal
  4991:
    tcp:
      - vrt
    udp:
      - vrt

share/services_hashes_dump.yml  view on Meta::CPAN

    - 998
  buschtrommel:
    - 4747
  business:
    - 3107
  busycal:
    - 4990
  bv-agent:
    - 3993
  bv-ds:
    - 3992

share/services_hashes_dump.yml  view on Meta::CPAN

    udp:
      3107:
        desc: Business protocol
        name: business
        note: ''
  busycal:
    tcp:
      4990:
        desc: BusySync Calendar Synch. Protocol
        name: busycal
        note: 'Defined TXT keys: Proprietary'
    udp:
      4990:
        desc: BusySync Calendar Synch. Protocol
        name: busycal
        note: 'Defined TXT keys: Proprietary'
  bv-agent:
    tcp:
      3993:
        desc: BindView-Agent

 view release on metacpan or  search on metacpan

examples/cal2fb.pl  view on Meta::CPAN

# (C) COPYRIGHT 2000-2001, Reefknot developers.
#
# See the AUTHORS file included in the distribution for a full list.
#======================================================================

# Demo of how to use freebusys.

use strict;

use lib '../lib';
use IO::File;

examples/cal2fb.pl  view on Meta::CPAN

$calfh->close();

# read the calendar file in to make a Calendar object. 
my $cal = Net::ICal::Calendar->new_from_ical($caldata);

my @busyperiods;
my $now = Net::ICal::Time->new(epoch => time());
my $dur = Net::ICal::Duration->new($durstr);
my $rperiod = Net::ICal::Period->new($now, $now->add($dur));

if (my $ar_events = $cal->events) {

examples/cal2fb.pl  view on Meta::CPAN

      my $end   = $period->end->timezone('UTC');
      # Make sure that we have a period with a fixed start/end
      # rather than one with a period
      $period = Net::ICal::Period->new($period->start, $period->end);
      $period->start->timezone('UTC');
      my $fbitem = Net::ICal::FreebusyItem->new($period);
      $fbitem->fbtype($fbtype);
      push(@busyperiods, $fbitem);
    }
  }
}

my $organizer = Net::ICal::Attendee->new($ENV{USER});
my $dtstamp   = Net::ICal::Time->new(epoch => time(), timezone => 'UTC');

my $fbs = Net::ICal::Freebusy->new(freebusy => \@busyperiods,
                                   organizer => $organizer,
				   dtstamp => $dtstamp,
				   dtstart => $rperiod->start,
				   dtend   => $rperiod->end);
my $fbcal = Net::ICal::Calendar->new(freebusys => [$fbs]);
print $fbcal->as_ical;

 view release on metacpan or  search on metacpan

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

### affect whole connection
use constant IMP_DENY         => dualvar(0x1100,"deny");
use constant IMP_DROP         => dualvar(0x1101,"drop");
use constant IMP_FATAL        => dualvar(0x1102,"fatal");

# these return values still get sent if the data provider is busy
# the most important are on top
use constant IMP_PASS_IF_BUSY => [
    IMP_FATAL,
    IMP_DENY,
    IMP_DROP,

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

=item $analyzer->poll_results => @results

Returns outstanding results.
If a callback is attached, no results will be delivered this way.

=item $analyzer->busy($dir,0|1)

Reports to the analyzer if the data provider is busy and cannot process all
requests. This is usually the case, if the upstream cannot keep up with the
data, so sending gets stalled.
While the data provider is busy the analyzer might still send return values,
which might resolve the busy state, like IMP_DENY, IMP_FATAL etc

=item Net::IMP->set_debug

This is just a convenient way to call C<< Net::IMP::Debug->set_debug >>.
See L<Net::IMP::Debug> for more information.

 view release on metacpan or  search on metacpan

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

                 0x0502 => "server-error-service-unavailable",
                 0x0503 => "server-error-version-not-supported",
                 0x0504 => "server-error-device-error",
                 0x0505 => "server-error-temporary-error",
                 0x0506 => "server-error-not-accepting-jobs",
                 0x0507 => "server-error-busy",
                 0x0508 => "server-error-job-canceled",
                 0x0509 => "server-error-multiple-document-jobs-not-supported",
                 0x050a => "server-error-printer-is-deactivated"
);

 view release on metacpan or  search on metacpan

docs/ldap.asn1  view on Meta::CPAN

    aliasDereferencingProblem    (36),
    -- 37-47 unused --
    inappropriateAuthentication  (48),
    invalidCredentials           (49),
    insufficientAccessRights     (50),
    busy                         (51),
    unavailable                  (52),
    unwillingToPerform           (53),
    loopDetect                   (54),
    -- 55-63 unused --
    namingViolation              (64),

 view release on metacpan or  search on metacpan

lib/Net/LDAP/SimpleServer.pm  view on Meta::CPAN

=head2 Internet Relay Chat

You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is,
please read this excellent guide: L<http://en.wikipedia.org/wiki/Internet_Relay_Chat>. Please
be courteous and patient when talking to us, as we might be busy or sleeping! You can join
those networks/channels and get help:

=over 4

=item *

 view release on metacpan or  search on metacpan

libnfs/README.multithreading  view on Meta::CPAN

See examples/nfs-pthreads-example.c for an example utility that
mounts a share, enables multithreading and then creates a  number of worker
threads that share the same nfs context.
(In the example the threads just runs a busy loop calling nfs_stat64().)


Porting
-------
The multithreading support is abstracted out into two separate files to make

 view release on metacpan or  search on metacpan

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

This boolean turns on warnings. You will get warnings for the following
situations:

=over

=item * A Mollom server is busy and we need to try a different one.

=item * We have exhausted the list of servers to try and we need to get a new list.

=back

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

                $self->servers_init(0);
                $self->server_list;
                return $self->_make_api_call($function, $args);
            }
        } elsif (($fault_code == $ERROR_NEXT_SERVER) && ($self->{_recurse_level} < $MAX_API_TRIES)) {
            carp("Mollom server busy, trying the next one.") if $self->warnings;
            my $next_index = $self->current_server + 1;
            if ($servers[$next_index] ) {
                $self->current_server($next_index);
                return $self->_make_api_call($function, $args);
            } else {

 view release on metacpan or  search on metacpan

NIS.pod  view on Meta::CPAN

    YPERR_YPSERV        Can't communicate with ypserv
    YPERR_NODOM         Local domain name not set
    YPERR_BADDB         yp data base is bad
    YPERR_VERS          YP version mismatch
    YPERR_ACCESS        Access violation
    YPERR_BUSY          Database is busy


=head1	ERRORS

Instead of having 'tie' succeed and the first access fail,

 view release on metacpan or  search on metacpan

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

Disabled by default. Controls whether signal handlers are installed for
SIGHUP, SIGINT, and SIGTERM prior to passing control to the collection
loop. Perl only sees these events when it is in context (i.e. during the
callback). Until then they are queued by default, until perl can handle
them. If you are polling on an interface that is not very busy, or if
your filters only occasionally pass an interesting message, it might be
a while before perl gets a chance to handle signals. With this option
enabled, the program is interruptable. Whatever signal handlers were in
place prior to invoking collect are restored once complete.

 view release on metacpan or  search on metacpan

lib/Net/Netconf/Access/ssh.pm  view on Meta::CPAN

    $self->trace("Will write $len bytes to the SSH channel:");
    $self->trace("$xml");

    # Make the channel blocking, so the write() call below waits until there
    # is available buffer space. Otherwise we'll end up busy-looping.
    $self->{'chan'}->blocking(1);

    my $written = 0;
    while($written != $len) {
        my $nbytes = $self->{'chan'}->write($xml)

lib/Net/Netconf/Access/ssh.pm  view on Meta::CPAN

    $self->trace("Reading XML response from Netconf server...");
    my ($resp, $buf);
    my $end_time = time() + 15;
    do {
        # Wait up to 10 seconds for data to become available before attempting
        # to read anything (in order to avoid busy-looping on $chan->read())
        my @poll = ({ handle => $chan, events => 'in' });
        $ssh2->poll(40000, \@poll);

        $nbytes = $chan->read($buf, 65536);

 view release on metacpan or  search on metacpan

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

=head2 download(video_id, file)

download() is a shortcut to download video which is identified by video_id.

For busy person, you can download a video by one liner like this:

    $ perl -MNet::NicoVideo -e 'Net::NicoVideo->new->download(@ARGV)' \
        smNNNNNN ./smile.mp4

Note that it is necessary to set environment variables in advance.