bless.* results from the CPAN

bless.*

AC-MrGamoo

view release on metacpan or search on metacpan

lib/AC/MrGamoo/Client.pm view on Meta::CPAN

sub new {
    my $class = shift;
    my $from = shift;	# file | text
    my $src  = shift;
    my $cfg  = shift;

    my $host = hostname();
    my $user = getpwuid($<);
    my $trace = "$user/$$\@$host:" . ($from eq 'file' ? $src : 'text');

    my $me   = bless {
        traceinfo	=> $trace,
    }, $class;
    $me->{fdebug} = $cfg->{debug} ? sub{ print STDERR "@_\n" } : sub {};

    # compile job
    my $mr = AC::MrGamoo::Submit::Compile->new( $from => $src );
    $me->{program} = $mr;

    # merge job %config section with passed in config
    $mr->add_config($cfg);

lib/AC/MrGamoo/D.pm view on Meta::CPAN


sub new {
    my $class = shift;
    my %p = @_;

    AC::MrGamoo::MySelf->customize(    $p{class_myself} );
    AC::MrGamoo::FileList->customize(  $p{class_filelist} );
    AC::MrGamoo::ReadInput->customize( $p{class_readinput} );
    # ...

    return bless \$class, $class;
}

sub daemon {
    my $me    = shift;
    my $cfile = shift;
    my $opt   = shift;	# foreground, debugall, persistent_id, argv

    die "no config file specified\n" unless $cfile;

    # configure

lib/AC/MrGamoo/EUConsole.pm view on Meta::CPAN

use AC::MrGamoo::Protocol;
use Socket;
use strict;


sub new {
    my $class  = shift;
    my $jobid  = shift;
    my $console = shift;	# ipaddr:port

    return bless {}, $class unless $console;

    # open socket to end-user console session, if requested
    my($addr, $port) = split /:/, $console;
    my $ip = inet_aton($addr);

    my $fd;
    my $i = socket($fd, PF_INET, SOCK_DGRAM, 0);
    $i = connect( $fd, sockaddr_in($port, $ip) );
    unless( $i ){
        verbose("cannot connect to user console: $!");
        return;
    }

    return bless {
        fd 	=> $fd,
        jobid	=> $jobid,
        msgid 	=> (time() & 0xFFFF),
    }, $class;
}

sub send_msg {
    my $me = shift;
    my $type = shift;
    my $msg  = shift;

lib/AC/MrGamoo/Iter/Array.pm view on Meta::CPAN


package AC::MrGamoo::Iter::Array;
use AC::MrGamoo::Iter;
our @ISA = 'AC::MrGamoo::Iter';
use strict;

sub new {
    my $class = shift;
    my $array = shift;  # [ [key, data], ...]

    return bless {
        src	=> $array,
    }, $class;
}

sub _nextrow {
    my $me = shift;

    if( $me->{buf} ){
        my $r = $me->{buf};
        delete $me->{buf};

lib/AC/MrGamoo/Iter/File.pm view on Meta::CPAN

use AC::MrGamoo::Iter;
use JSON;
our @ISA = 'AC::MrGamoo::Iter';
use strict;

sub new {
    my $class = shift;
    my $fd    = shift;
    my $pf    = shift;

    return bless {
        fd	 => $fd,
        progress => $pf,
    }, $class;
}

sub _nextrow {
    my $me = shift;

    if( $me->{buf} ){
        my $r = $me->{buf};

lib/AC/MrGamoo/Job.pm view on Meta::CPAN

    freq	=> 2,
    func	=> \&periodic,
   );

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

sub new {
    my $class = shift;
    # %{ APCMRMJobCreate }

    my $me = bless {
        request		=> { @_ },
        phase_no	=> -1,
        file_info	=> {},
        tmp_file	=> [],
        server_info	=> {},
        task_running	=> {},
        task_pending	=> {},
        xfer_running	=> {},
        xfer_pending	=> {},
        request_running	=> {},

lib/AC/MrGamoo/Job/Plan.pm view on Meta::CPAN

    for my $ts (@task){
        for my $t ( @{$ts->{task}} ){
            $task{ $t->{id} } = $t;
        }
    }

    # debug("plan: " . dumper( \@task ));

    debug("infiles: " . @$files . ", precopy: " . @$plancopy . ", maps: " . @$planmap . ", reduces: $nr x $nrp");

    return bless {
        nserver		=> scalar(@$servers),
        nreduce		=> $nr,
        copying		=> $plancopy,
        phases		=> \@phase,
        taskplan	=> \@task,
        redbin		=> $redbin,
        taskidx		=> \%task,
    }, $class;
}

lib/AC/MrGamoo/Job/Request.pm view on Meta::CPAN

package AC::MrGamoo::Job::Request;
use AC::MrGamoo::Debug 'job_request';
use strict;

our @ISA = 'AC::MrGamoo::Job::Action';

sub new {
    my $class = shift;
    my $job   = shift;

    my $me = bless { @_ }, $class;

    $job->{request_pending}{$me->{id}} = $me;
    return $me;
}

sub start {
    my $me  = shift;
    my $job = shift;

    debug("starting request $me->{info}");

lib/AC/MrGamoo/Job/Task.pm view on Meta::CPAN



sub new {
    my $class  = shift;
    my $job    = shift;
    my $info   = shift;
    my $server = shift;

    my $id = unique();

    my $me = bless {
        id	=> $id,
        info	=> $info,
        server	=> $server,
        created => time(),
    };

    $job->{task_pending}{$id} = $me;

    debug("  => pending task $info->{id} => $id on $server");

lib/AC/MrGamoo/Job/TaskInfo.pm view on Meta::CPAN

use strict;

our @ISA = 'AC::MrGamoo::Job::Info';

my $MAXRETRY = 2;

sub new {
    my $class = shift;
    my $job   = shift;

    return bless { @_ }, $class;
}

sub pend {
    my $me  = shift;
    my $job = shift;

    return if $me->{replaced};
    return if $me->{finished};

    # create instance, put on pending queue

lib/AC/MrGamoo/Job/Xfer.pm view on Meta::CPAN



sub new {
    my $class  = shift;
    my $job    = shift;
    my $info   = shift;
    my $server = shift;

    my $id = unique();

    my $me = bless {
        id	=> $id,
        info	=> $info,
        server	=> $server,
        created => $^T,
    };

    $job->{xfer_pending}{$id} = $me;

    debug("pending xfer $info->{id} => $id on $server");

lib/AC/MrGamoo/Job/XferInfo.pm view on Meta::CPAN


our @ISA = 'AC::MrGamoo::Job::Info';

my $MAXRETRY = 1;

# id, filename, dstname, size, location, dst
sub new {
    my $class = shift;
    my $job   = shift;

    my $me = bless { @_ }, $class;
    $me->{server} = $me->{dst};

    return $me;
}

sub pend {
    my $me  = shift;
    my $job = shift;

    # create instances, put on pending queue

lib/AC/MrGamoo/OutFile.pm view on Meta::CPAN

$max_open = `sh -c "ulimit -n"`;
$max_open = 255 if $^O eq 'solaris' && $max_open > 255;
$max_open -= 32;	# room for other fds


sub new {
    my $class = shift;
    my $file  = shift;
    my $gz    = shift;

    my $me = bless {
        file	=> $file,
        gz      => $gz,
    }, $class;

    $all{$file} = $me;

    # open as many as we can up front
    $me->_open() if $currently_open < $max_open;
    return $me;
}

lib/AC/MrGamoo/Retry.pm view on Meta::CPAN

package AC::MrGamoo::Retry;
our @ISA = 'AC::DC::Callback';

use AC::MrGamoo::Debug 'retry';
use strict;

# newobj, newargs, tryeach
sub new {
    my $class = shift;

    my $me = bless { @_, tries => 0 }, $class;

    $me->{tryeach}  ||= [];
    $me->{maxtries} ||= @{ $me->{tryeach} };
    return $me;
}

sub start {
    my $me = shift;

    $me->_try();

lib/AC/MrGamoo/Submit/Compile.pm view on Meta::CPAN


my %BLOCK = (
    init	=> 'simple',
    cleanup	=> 'simple',
    attr	=> 'config',
   );

sub new {
    my $class = shift;

    my $me = bless {
        @_,
        # file | text
    }, $class;

    if( $me->{file} ){
        open(my $fd, $me->{file}) || $me->_die("cannot open file: $!");
        local $/ = undef;
        $me->{text} = <$fd>;
        close $fd;
    }

lib/AC/MrGamoo/Submit/Compile/Block.pm view on Meta::CPAN

# $Id: Block.pm,v 1.1 2010/11/01 18:42:00 jaw Exp $

package AC::MrGamoo::Submit::Compile::Block;
use strict;

my $UCLASS = 'AC::MrGamoo::User';

sub new {
    my $class = shift;

    return bless {}, $class;
}

sub compile {
    my $me   = shift;
    my $inc  = shift;

    my $prog = "{\n";

    my $class = $me->{attr}{in_package} || $UCLASS;
    $prog .= "package $class;\n";

lib/AC/MrGamoo/Submit/Request.pm view on Meta::CPAN

use AC::Misc;
use AC::Daemon;
use AC::ISOTime;
use strict;


sub new {
    my $class = shift;
    my $c     = shift;

    my $me = bless {
        file	=> $c->{file},
        config	=> $c->{content}{config},
        initres	=> $c->{initres},
        @_,
    }, $class;

    $AC::MrGamoo::User::R = $me;
    return $me;
}

lib/AC/MrGamoo/Submit/TieIO.pm view on Meta::CPAN

#
# $Id: TieIO.pm,v 1.1 2010/11/01 18:42:00 jaw Exp $

package AC::MrGamoo::Submit::TieIO;
use strict;

sub TIEHANDLE {
    my $class = shift;
    my $func  = shift;

    return bless{ func => $func }, $class;
}

sub PRINT {
    my $me = shift;

    return unless $me->{func};
    $me->{func}->( @_ );
}

sub PRINTF {

lib/AC/MrGamoo/Task.pm view on Meta::CPAN

    freq	=> 5,
    func	=> \&periodic,
   );

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

sub new {
    my $class = shift;
    # %ACPMRMTaskCreate

    my $me = bless {
        request		=> { @_ },
    }, $class;
    debug("new task $me->{request}{taskid}");

    my $task = $me->{request}{taskid};
    return problem("cannot create task: no task id")   unless $task;
    if( $REGISTRY{$task} ){
        verbose("ignoring duplicate request task $task");
        # will cause a 200 OK, so the requestor will not retry
        return $REGISTRY{$task};

( run in 0.841 second using v1.01-cache-2.11-cpan-4505f990765 )