view release on metacpan or  search on metacpan

lib/Net/Hadoop/Oozie.pm  view on Meta::CPAN

}

sub oozie_version {
    my $self = shift;
    my $build = $self->build_version;
    my($v) = split m{ [-] }xms, $build, 2;
    return $v;
}

sub max_node_name_len {
    my $self    = shift;

 view release on metacpan or  search on metacpan

lib/Net/Hadoop/YARN/ApplicationMaster.pm  view on Meta::CPAN

}

sub _extract_ids_from_error_html {
    my $self  = shift;
    my $error = shift || Carp::confess "No error message specified!";
    my(undef, $html) = split m{\Q<!DOCTYPE\E}xms, $error, 2;
    $html = '<!DOCTYPE' . $html;
    my $parser = HTML::PullParser->new(
                    doc         => \$html,
                    start       => 'event, tagname, @attr',
                    report_tags => [qw( a )],

 view release on metacpan or  search on metacpan

contrib/hand_test01.pl  view on Meta::CPAN

use Data::Dump qw(dump);

my $imap = slurp_fetchmail->login(use_ssl=>1);

my @c;
for my $box (map {split m/\s+/} (@ARGV ? @ARGV : ("INBOX"))) {
    push @c, {
        selectres => dump($imap->select($box)), 
        box => $imap->current_box, first_unseen=>$imap->unseen, recent=>$imap->recent,
    };
}

 view release on metacpan or  search on metacpan

lib/Net/IP/Match/Bin/Perl.pm  view on Meta::CPAN

      my $match = $map[ $i + 1 ];
      if ($match eq "-1") {
	  $match = "$range";
      }

      my ( $ip, $mask ) = split m/\//xms, $range;
      if (! defined $mask) {
         $mask = 32;          ## no critic(MagicNumbers)
      }

      my $tree = $self->{Tree}; # root

 view release on metacpan or  search on metacpan

lib/Net/IP/Match/Regexp.pm  view on Meta::CPAN

IPRANGE:
   for ( my $i = 0; $i < @map; $i += 2 ) {
      my $range = $map[ $i ];
      my $match = $map[ $i + 1 ];

      my ( $ip, $mask ) = split m/\//xms, $range;
      if (! defined $mask) {
         $mask = 32;          ## no critic(MagicNumbers)
      }

      my $tree = \%tree;
      my @bits = split m//xms, unpack 'B32', pack 'C4', split m/[.]/xms, $ip;

      for my $bit ( @bits[ 0 .. $mask - 1 ] ) {

         # If this case is hit, it means that our IP range is a subset
         # of some other range, and thus ignorable

lib/Net/IP/Match/Regexp.pm  view on Meta::CPAN

   return if !$ip;
   return if !$re;

   local $LAST_REGEXP_CODE_RESULT = undef;
   use re 'eval';
   ( '4' . unpack 'B32', pack 'C4', split m/[.]/xms, $ip ) =~ m/$re/xms;
   return $LAST_REGEXP_CODE_RESULT;
}

# Helper function.  This recurses to build the regular expression
# string from a tree of IP ranges constructed by

 view release on metacpan or  search on metacpan

lib/Net/IP/Match/Trie/PP.pm  view on Meta::CPAN

    my $ad;
    my $nm = 0xFFFFFFFF;

    ### name: $name
    for my $cidr (@$cidrs) {
        my($ip, $len) = split m{/}, $cidr, 2;
        $len ||= 32;
        ### cidr, ip, len: join ', ', $cidr, $ip, $len

        $ad = unpack "N", inet_aton($ip);
        $nm = itonetmask($len);

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

if (!ExtUtils::PkgConfig->exists($PKG)) {
    die "Your pkg-config can’t find $PKG; aborting …\n";
}

my @pc_cflags = split m< >, ExtUtils::PkgConfig->cflags($PKG);

my @libs = split m< >, ExtUtils::PkgConfig->libs($PKG);

my @pc_lddlflags = map { $_ ? (split m< >) : () } (
    ExtUtils::PkgConfig->libs_only_L($PKG),
    ExtUtils::PkgConfig->libs_only_other($PKG),
);

my @cflags = (

 view release on metacpan or  search on metacpan

lib/Net/NSCA/Client/Connection/TLS.pm  view on Meta::CPAN

# PRIVATE METHODS
sub _xor_encrypt {
	my ($self, $byte_stream, $iv) = @_;

	# Make a byte array of the IV
	my @byte_iv = split m{}msx, $iv;

	# Make a byte array of the password if there is a password
	my @byte_password = $self->has_password ? (split m{}msx, $self->password) : ();

	# Convert the byte stream into an array for manipulation
	my @byte_stream = split m{}msx, $byte_stream;

	foreach my $byte_index (0..$#byte_stream) {
		# Foreach byte in the byte stream, XOR the byte with the IV
		$byte_stream[$byte_index] ^= $byte_iv[$byte_index % scalar @byte_iv];

 view release on metacpan or  search on metacpan

NetSend.pm  view on Meta::CPAN

					$confirm_packets, 
					0);

#	print "\n\nGroup id: ". ord($MBM_MESSAGE_GROUP_ID) . "\n\n";

	#split message into parts
	my @messageparts;
	for(my $start =0; $start < length($mbmessage); $start+=128){
		push @messageparts, substr($mbmessage, $start, 128);
	}
	

 view release on metacpan or  search on metacpan

lib/Net/Nostr/Git.pm  view on Meta::CPAN

        my $data = decode_naddr($rest);
        return $data;
    }

    # owner/[relay-hint/]identifier form
    my @parts = split m{/}, $rest, -1;
    my $owner = $parts[0];
    croak "owner must not be empty" unless defined $owner && length $owner;
    croak "nostr:// clone URL requires an identifier" if @parts < 2;

    if (@parts == 2) {

 view release on metacpan or  search on metacpan

t/02detail.t  view on Meta::CPAN

# Client should automatically include ::PerlCollector
my $client = Net::Prometheus->new;

# perl_heap_svs_by_type
{
   my @by_type = grep { m/^perl_heap_svs_by_type/ } split m/\n/, $client->render;

   # Don't need to test all the SV types but this should be sufficient
   ok( (grep { m/^perl_heap_svs_by_type\{type="ARRAY"} [1-9]\d+/ } @by_type),
      'Render output contains a non-zero count of ARRAYs' );
   ok( (grep { m/^perl_heap_svs_by_type\{type="CODE"} [1-9]\d+/ } @by_type),

 view release on metacpan or  search on metacpan

lib/Net/Prometheus/ProcessCollector/linux.pm  view on Meta::CPAN

   # To report process_start_time_seconds correctly, we need the machine boot
   # time
   if( !defined $BOOTTIME ) {
      foreach my $line ( do { open my $fh, "<", "/proc/stat"; <$fh> } ) {
         next unless $line =~ m/^btime /;
         $BOOTTIME = +( split m/\s+/, $line )[1];
         last;
      }
   }

   my $self = $class->__new( %args );

lib/Net/Prometheus/ProcessCollector/linux.pm  view on Meta::CPAN

{
   my $line = ( grep m/^Max open files/, $self->_read_procfile( "limits" ) )[0];
   defined $line or return undef;

   # Max open files  $SOFT  $HARD
   return +( split m/\s+/, $line )[3];
}

sub collect ( $self, $opts = undef )
{
   my $statline = $self->_read_procfile( "stat" );

 view release on metacpan or  search on metacpan

t/lib/Test/Net/SAJAX/UserAgent.pm  view on Meta::CPAN

		$handle_request = sub {
			# Get the key pairs from the content
			my %content = map {
				URI::Escape::uri_unescape($_)
			} map {
				split m{=}msx
			} split m{&}msx, $request->decoded_content;

			return $self->post($request->uri, \%content);
		};
	}

 view release on metacpan or  search on metacpan

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

         return $this->_error(
            'The start index "%s" is expected in dotted decimal notation',
            $argv[2]
         );
      }
      my @subids = split m/\./, $argv[2];
      if ($subids[-1] > 0) {
         $subids[-1]--;
      } else {
         pop @subids;
      }

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

   defined $oid  || return FALSE;

   $base =~ s/^\.//o;
   $oid  =~ s/^\.//o;

   $base = pack 'N*', split m/\./, $base;
   $oid  = pack 'N*', split m/\./, $oid;

   return (substr($oid, 0, length $base) eq $base) ? TRUE : FALSE;
}

sub oid_context_match

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

   my ($aa, $bb) = @_;

   for ($aa, $bb) {
      s/^\.//;
      s/ /\.0/g;
      $_ = pack 'N*', split m/\./;
   }

   return $aa cmp $bb;
}

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

                map
                {
                   my $oid = $_;
                   $oid =~ s/^\.//;
                   $oid =~ s/ /\.0/g;
                   [$_, pack 'N*', split m/\./, $oid]
                } @_;
}

=head2 snmp_type_ntop() - convert an ASN.1 type to presentation format

 view release on metacpan or  search on metacpan

lib/Net/Statsd/Server/Backend/Elasticsearch.pm  view on Meta::CPAN

  my @timer_data;

  $timestamp *= 1000;

  for my $key (keys %{ $metrics->{counters} }) {
    #my @keys = split m{\.}, $key;
    if (defined $elasticFilter && $key !~ $elasticFilter) {
      next;
    }
    my $value = $metrics->{counters}->{$key};
    #push @counts, {

lib/Net/Statsd/Server/Backend/Elasticsearch.pm  view on Meta::CPAN

    };
    $numStats++;
  }

  for my $key (keys %{ $metrics->{timers} }) {
    my @keys = split m{\.}, $key;
    my $series = $metrics->{timers}->{$key};
    if (defined $elasticFilter && $key !~ $elasticFilter) {
      next;
    }
    for my $keyTimer (keys %{ $series }) {

lib/Net/Statsd/Server/Backend/Elasticsearch.pm  view on Meta::CPAN

#     };
    }
  }

  for my $key (keys %{ $metrics->{timer_data} }) {
    my @keys = split m{\.}, $key;
    if (defined $elasticFilter && $key !~ $elasticFilter) {
      next;
    }
    my $value = $metrics->{timer_data}->{$key};
    $value->{'@timestamp'} = $timestamp;

 view release on metacpan or  search on metacpan

t/MockServer.pm  view on Meta::CPAN

            if (@bits == 0 || ! defined $bits[0]) {
                push @bits, 1;
            }

            for (@bits) {
                my @fields = split m{\|};

                if (@fields == 1 || ! defined $fields[1]) {
                    $msg->{error} = "bad line";
                    next;
                }

 view release on metacpan or  search on metacpan

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

}

sub subnet_matcher {
    @_ > 1 and goto &multi_matcher;

    my ($net, $mask) = split m[/], shift;
    return $net =~ /:/
        ? ipv6_matcher($net, $mask)
        : ipv4_matcher($net, $mask);
}

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

}

sub sort_subnets {
    my @unsorted;
    for (@_) {
        my ($net, $mask) = split m[/];

        $mask = $net =~ /:/
            ? ($mask =~ /:/ ? inet_pton(AF_INET6, $mask) : cidr2mask_v6($mask))
            : ($mask =~ /\./ ? inet_aton($mask) : cidr2mask_v4($mask));

 view release on metacpan or  search on metacpan

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

            next;
        }
        if ($alias && m/${_brcd_wwn_re}/) {
            s/^\s*//; # on enleve les blancs de devant
            DEBUG && warn "DEBUG: aliShow: $alias: $_\n";
            my @wwn_for_alias = split m/\s*;\s*/;
            foreach my $wwn (@wwn_for_alias) {
                $fab->{WWN}->{$wwn}     = $alias;
            }
            if (exists $fab->{ALIAS}->{$alias}) {
                my $old_alias_value = $fab->{ALIAS}->{$alias};

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

            $zone = $1;
            next;
        }
        if ($zone && m/\s*(\w[:\w\s;]+)/) {
            my $members = $1;
            my @member  = split m/;\s+/, $members;

            foreach my $member (@member) {
                $fab->{ZONE}->{$zone}->{$member}++;
                $fab->{MEMBER}->{$member}->{$zone}++;
            }

 view release on metacpan or  search on metacpan

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

sub import {
    my $class = shift;
    my @tags  = @_;

    foreach my $tag ( @tags ) {
        my $module = join q{::}, $class, "Util", join q{}, map { ucfirst } split m{_}, $tag;
        eval "require $module"
            or die;
        $module->import;
    }
}

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

sub new {
    my $class   = shift;
    my $address = shift;
    my %self;

    my( $host, $cidr ) = split m{/}, $address;

    my $version = $host =~ m{[.]} ? 4 : $host =~ m{[:]} ? 6 : undef;
    my $module  = join q{::}, $class, "Address", "v$version";

    unless ( defined $cidr ) {

 view release on metacpan or  search on metacpan

demo/123_server.pl  view on Meta::CPAN

if (index($host_port, ':') == -1) {
    substr( $host_port, 0, 0 ) = '127.0.0.1:';
}

my ($host, $port) = split m<:>, $host_port;

my $server = IO::Socket::INET->new(
    LocalHost => $host,
    LocalPort => $port,
    ReuseAddr => 1,

 view release on metacpan or  search on metacpan

t/gtalk.t  view on Meta::CPAN

    my $to = $presence->GetTo;
    my $from = $presence->GetFrom;
    my $type = $presence->GetType || 'available';
    my $status = $presence->GetStatus || '';

    ($to)   = split m{/}, $to;
    ($from) = split m{/}, $from;

    diag "$to - $from - $type - $status";
}

sub on_receive {

 view release on metacpan or  search on metacpan

lib/NetServer/Portal/Pi.pm  view on Meta::CPAN

    my ($o, $path) = @_;
    my @at = (@{$o->{Package}}, @{$o->{Path}});
    @at=()
	if $path =~ s,^/,,;
    if ($path =~ m,^[\w\.\:/-]+$,) {
	my @step = split m'/+', $path;
	for my $step (@step) {
	    next if $step eq '.';
	    if ($step eq '..') {
		pop @at;
	    } else {

 view release on metacpan or  search on metacpan

t/NoSQL-PL2SQL-Simple.t  view on Meta::CPAN

# Insert your test code below, the Test::More module is use()ed here so read
# its man page ( perldoc Test::More ) for help writing this test script.

sub testpath {
	my @path = split m|/|, ":$0" ;
	pop @path ;
	$path[0] =~ s/^:// ;
	return join '/', @path, @_ ;
	}

 view release on metacpan or  search on metacpan

Nobody/Util.pm  view on Meta::CPAN

  my ($a, $b) = (
    @_ == 2 ? (shift, shift) :
    @_       ? do { warn "Warning: vcmp wants 2 args or none"; (undef, undef) } :
               ($a, $b)
  );
  my @a = split m{(\D+)}, $a;
  my @b = split m{(\D+)}, $b;
  no warnings;
  while (@a and @b and $a[0] eq $b[0]) {
    shift @a;
    shift @b;
  }

 view release on metacpan or  search on metacpan

lib/OPC.pm  view on Meta::CPAN

    lc $FullName;
  };

  # обрабатываем все . и .. в имени
  my @CleanedSegments;
  my @OriginalSegments = split m:/:, $FullName;
  for my $Part ( @OriginalSegments ) {
    if( $Part eq '.' ) {
      # просто пропускаем
    } elsif( $Part eq '..' ) {
      if( @CleanedSegments > 0 ) {

 view release on metacpan or  search on metacpan

lib/OPM/Maker/Command/sopm.pm  view on Meta::CPAN

    if ( $json->{changes_file} && -f $config->dir . "/" . $json->{changes_file} ) {
        my $changes_file = Path::Class::File->new( $config->dir, $json->{changes_file} );
        my $lines        = $changes_file->slurp( iomode => '<:encoding(UTF-8)' );

        my @entries = grep{ ( $_ // '' ) ne '' }split m{
            (?:\s+)?
            (                         # headline with version and date
                ^
                \d+\.\d+ (?:\.\d+)?   # version
                \s+ - \s+

 view release on metacpan or  search on metacpan

lib/OTRS/OPM/Maker/Command/changes.pm  view on Meta::CPAN

    my $lines;

    if ( -f $changes_file->stringify ) {
        $lines = $changes_file->slurp( iomode => '<:encoding(UTF-8)' );

        my @entries = grep{ ( $_ // '' ) ne '' }split m{
            (?:\s+)?
            (                                         # headline with version and date
                ^
                \d+\.\d+ (?:\.\d+)?                   # version
                \s+ -? \s+

 view release on metacpan or  search on metacpan

lib/OTRS/OPM/Maker/Command/sopm.pm  view on Meta::CPAN

    if ( $json->{changes_file} && -f $config->dir . "/" . $json->{changes_file} ) {
        my $changes_file = Path::Class::File->new( $config->dir, $json->{changes_file} );
        my $lines        = $changes_file->slurp( iomode => '<:encoding(UTF-8)' );

        my @entries = grep{ ( $_ // '' ) ne '' }split m{
            (?:\s+)?
            (                         # headline with version and date
                ^
                \d+\.\d+ (?:\.\d+)?   # version
                \s+ - \s+

 view release on metacpan or  search on metacpan

scripts/similarity_match.pl  view on Meta::CPAN

		# to signal sections irrespective of actual line endings
		# this is a major headache to resolve, the parser doesn't 
		# do this and we're not going to bother with it either
		$alt =~ s/;;//g; 
		$alt =~ s/INCLUDED//g; # remove INCLUDED as it screws up scoring
		my @synonyms = split m!\n!, $alt;
		# if alt doesn't start with ;; it's an overspill from the
		# title (go figure!)
		if ($alt ne '' && 
				$omim_entry->alternative_titles_and_symbols() !~ /^;;/) {
			$title .= shift @synonyms;

 view release on metacpan or  search on metacpan

lib/ObjStore/PathExam/Path.pm  view on Meta::CPAN

use base 'ObjStore::AV';

sub new {
    use attrs 'method';
    my ($class, $near, $path) = @_;
    my @comp = split m",\s*", $path;
    croak "$class->new($path): invalid" if @comp==0;
    my $o = $class->SUPER::new($near, scalar @comp);
    for (my $x=0; $x < @comp; $x++) {
	my @c = split m"\/", $comp[$x];
	croak "$class->new($path): '$comp[$x]' too long" if @c > 7;
	$o->[$x] = [map { "$_\0" } @c];
    }
    $o;
}