Changeset e4ae52787f79097612444755cba6f78dee723cfe in xas


Ignore:
Timestamp:
09/01/15 14:39:57 (3 years ago)
Author:
Kevin L. Esteb <kevin@…>
Branches:
master
Children:
392adcd20f1c8ba78b4f37cc8a7d45febb1491ce
Parents:
3aa185bfecd34f5a0f526297df835f6484df31ac
git-author:
Kevin L. Esteb <kevin@…> (09/01/15 14:39:57)
git-committer:
Kevin L. Esteb <kevin@…> (09/01/15 14:39:57)
Message:

Working with the batch modules.

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/MANIFEST

    r745857a054f3828728165a363e851100df3f0464 re4ae52787f79097612444755cba6f78dee723cfe  
    3131lib/XAS/Lib/App/Service/Unix.pm 
    3232lib/XAS/Lib/App/Service/Win32.pm 
     33lib/XAS/Lib/Batch.pm 
     34lib/XAS/Lib/Batch/Job.pm 
     35lib/XAS/Lib/Batch/Queue.pm 
     36lib/XAS/Lib/Batch/Server.pm 
     37lib/XAS/Lib/Batch/Interface/Torque.pm 
    3338lib/XAS/Lib/Curl/HTTP.pm 
    3439lib/XAS/Lib/Mixins/Bufops.pm 
  • trunk/lib/XAS.pm

    rc9684eac53802f37f49feca31c47077e6f8884d3 re4ae52787f79097612444755cba6f78dee723cfe  
    4747 
    4848=item L<XAS::Lib::App::Service::Win32|XAS::Lib::App::Service::Win32> 
     49 
     50=item L<XAS::Lib::Batch|XAS::Lib::Batch> 
     51 
     52=item L<XAS::Lib::Batch::Job|XAS::Lib::Batch::Job> 
     53 
     54=item L<XAS::Lib::Batch::Queue|XAS::Lib::Batch::Queue> 
     55 
     56=item L<XAS::Lib::Batch::Server|XAS::Lib::Batch::Server> 
     57 
     58=item L<XAS::Lib::Batch::Interface::Torque|XAS::Lib::Batch::Interface::Torque> 
    4959 
    5060=item L<XAS::Lib::Curl::HTTP|XAS::Lib::Curl::HTTP> 
  • trunk/lib/XAS/Lib/Batch/Interface/Torque.pm

    r96f11eb731229de55299aa08ec81c182fd951cfe re4ae52787f79097612444755cba6f78dee723cfe  
    1010  base    => 'XAS::Base', 
    1111  utils   => 'trim', 
    12   mixins  => 'do_qsub do_qstat do_qdel do_qsig do_qhold do_qrls do_qmove  
    13               do_qmsg do_qrerun do_queue_stat do_queue_stop do_queue_start 
    14               do_server_stat do_server_enable do_server_disable', 
     12  mixins  => 'do_job_sub do_job_stat do_job_del do_job_sig do_job_hold  
     13              do_job_rls do_job_move do_job_msg do_job_rerun do_queue_stat  
     14              do_queue_stop do_queue_start do_server_stat do_server_enable  
     15              do_server_disable', 
    1516  constant => { 
    1617    QSUB     => '/usr/bin/qsub', 
     
    3738# ---------------------------------------------------------------------- 
    3839 
    39 sub do_qsub { 
     40sub do_job_sub { 
    4041    my $self = shift; 
    4142    my ($p) = $self->validate_params(\@_, [ 
     
    5455} 
    5556 
    56 sub do_qstat { 
     57sub do_job_stat { 
    5758    my $self = shift; 
    5859    my ($p) = $self->validate_params(\@_, [ 
     
    6970} 
    7071 
    71 sub do_qdel { 
     72sub do_job_del { 
    7273    my $self = shift; 
    7374    my ($p) = $self->validate_params(\@_, [ 
     
    8990} 
    9091 
    91 sub do_qsig { 
     92sub do_job_sig { 
    9293    my $self = shift; 
    9394    my ($p) = $self->validate_params(\@_, [ 
     
    103104} 
    104105 
    105 sub do_qhold { 
     106sub do_job_hold { 
    106107    my $self = shift; 
    107108    my ($p) = $self->validate_params(\@_, [ 
     
    129130} 
    130131 
    131 sub do_qrls { 
     132sub do_job_rls { 
    132133    my $self = shift; 
    133134    my ($p) = $self->validate_params(\@_, [ 
     
    155156} 
    156157 
    157 sub do_qmove { 
     158sub do_job_move { 
    158159    my $self = shift; 
    159160    my ($p) = $self->validate_params(\@_, [ 
     
    170171} 
    171172 
    172 sub do_qmsg { 
     173sub do_job_msg { 
    173174    my $self = shift; 
    174175    my ($p) = $self->validate_params(\@_, [ 
     
    184185} 
    185186 
    186 sub do_qrerun { 
     187sub do_job_rerun { 
    187188    my $self = shift; 
    188189    my ($p) = $self->validate_params(\@_, [ 
     
    459460=head1 NAME 
    460461 
    461 XAS::Lib::Mixins::xxxx - A mixin for the XAS environment 
     462XAS::Lib::Batch::Interface::Torque - A mixin for the XAS environment 
    462463 
    463464=head1 SYNOPSIS 
     
    467468   version => '0.01', 
    468469   base    => 'XAS::Base', 
    469    mixin   => 'XAS::Lib::Mixins::xxxx' 
     470   mixin   => 'XAS::Lib::Batch::Interface::Torque' 
    470471; 
    471472 
    472473=head1 DESCRIPTION 
    473474 
    474 =head1 METHODS 
    475  
    476 =head2 method1 
     475In the Unix world, there is a standardized interface for Batch Systems. In 
     476honor of this standard, each implementation has a slightly different command 
     477line syntax. This mixin implements the PBS/Torque command line.  
    477478 
    478479=head1 SEE ALSO 
     
    480481=over 4 
    481482 
     483=item L<XAS::Lib::Batch|XAS::Lib::Batch> 
     484 
    482485=item L<XAS|XAS> 
    483486 
     
    490493=head1 COPYRIGHT AND LICENSE 
    491494 
    492 Copyright (c) 2014 Kevin L. Esteb 
     495Copyright (c) 2015 Kevin L. Esteb 
    493496 
    494497This is free software; you can redistribute it and/or modify it under 
  • trunk/lib/XAS/Lib/Batch/Job.pm

    re5ded116dbf8a4f73f0c6b5413b8f165f1d54285 re4ae52787f79097612444755cba6f78dee723cfe  
    44 
    55use XAS::Class 
    6   debug     => 0, 
    7   version   => $VERSION, 
    8   base      => 'XAS::Lib::Batch', 
    9   constants => 'DELIMITER', 
     6  debug      => 0, 
     7  version    => $VERSION, 
     8  base       => 'XAS::Lib::Batch', 
     9  filesystem => 'Dir', 
     10  constants  => 'DELIMITER', 
    1011  constant => { 
    1112    TYPES  => qr/user|other|system|none|,|\s/, 
     
    2728        -jobfile => { isa => 'Badger::Filesystem::File' }, 
    2829        -logfile => { isa => 'Badger::Filesystem::File' }, 
    29         -rerunable   => { optional => 1, default => 'y' }, 
     30        -rerunable   => { optional => 1, default => 'n' }, 
    3031        -join_path   => { optional => 1, default => 'oe' }, 
    3132        -account     => { optional => 1, default => undef }, 
     
    4142        -after       => { optional => 1, isa => 'DateTime' }, 
    4243        -shell_path  => { optional => 1, default => '/bin/sh' }, 
    43         -work_path   => { optional => 1, default => '/tmp' }, 
     44        -work_path   => { optional => 1, isa => 'Badger::Filesystem::Directory', default => Dir('/', 'tmp') }, 
    4445        -priority    => { optional => 1, default => 0, callbacks => { 
    4546            'out of priority range' => 
     
    4849    }); 
    4950 
    50     return $self->do_qsub($p); 
     51    return $self->do_job_sub($p); 
    5152 
    5253} 
     
    5960    }); 
    6061 
    61     return $self->do_qstat($p); 
     62    return $self->do_job_stat($p); 
    6263 
    6364} 
     
    7273    }); 
    7374 
    74     return $self->do_qdel($p); 
     75    return $self->do_job_del($p); 
    7576 
    7677} 
     
    8485    }); 
    8586 
    86     return $self->do_qsig($p); 
     87    return $self->do_job_sig($p); 
    8788 
    8889} 
     
    9697    }); 
    9798 
    98     return $self->do_qhold($p); 
     99    return $self->do_job_hold($p); 
    99100 
    100101} 
     
    108109    }); 
    109110 
    110     return $self->do_qrls($p); 
     111    return $self->do_job_rls($p); 
    111112 
    112113} 
     
    121122    }); 
    122123 
    123     return $self->do_qmove($p); 
     124    return $self->do_job_move($p); 
    124125 
    125126} 
     
    134135    }); 
    135136 
    136     return $self->do_qmsg($p); 
     137    return $self->do_job_msg($p); 
    137138 
    138139} 
     
    145146    }); 
    146147 
    147     return $self->do_qrerun($p); 
     148    return $self->do_job_rerun($p); 
    148149 
    149150} 
     
    175176    }); 
    176177 
    177     return $self->do_qalter($p); 
     178    return $self->do_job_alter($p); 
    178179 
    179180} 
     
    195196 use XAS::Lib::Batch::Job; 
    196197 
    197  my $batch = XAS::Lib::Batch::Job->new(); 
    198  
    199  my $id = $batch->qsub(...); 
     198 my $job = XAS::Lib::Batch::Job->new(); 
     199 
     200 my $id = $job->qsub(...); 
    200201  
    201202 printf("job %s has started\n", $id); 
    202203 
    203  while (my $stat = $batch->qstat(-job => $id)) { 
     204 while (my $stat = $job->qstat(-job => $id)) { 
    204205 
    205206     if ($stat->{job_state} eq 'C') { 
     
    215216=head1 DESCRIPTION 
    216217 
     218This module provides an interface for manipulating jobs in a Batch System.  
     219Each available method is a wrapper around a given command. A command line 
     220is built, executed, and the return code is checked. If the return code is 
     221non-zero an exception is thrown. The exception will include the return code 
     222and the first line from stderr. 
     223 
     224Since each method is a wrapper, there is a corresponding man page for the  
     225actual command. They should also be checked when problems arise. 
     226 
    217227=head1 METHODS 
    218228 
    219 =head2 method1 
     229=head2 new 
     230 
     231This method initializes the module and takes these parameters: 
     232 
     233=over 4 
     234 
     235=item B<-interface> 
     236 
     237The command line interface to use. This defaults to 'XAS::Lib::Batch::Interface::Torque'. 
     238 
     239=back 
     240 
     241=head2 qsub(...) 
     242 
     243This method will submit a job to the batch system and returns the jobs ID. It  
     244takes the following parameters: 
     245 
     246=over 4 
     247 
     248=item B<-jobname> 
     249 
     250The name of the job. 
     251 
     252=item B<-queue> 
     253 
     254The queue to run the job on. 
     255 
     256=item B<-email> 
     257 
     258The email address to send status reports too. There can be more then one 
     259address or this can be a mailing list. 
     260 
     261=item B<-command> 
     262 
     263The command to run. 
     264 
     265=item B<-jobfile> 
     266 
     267The name of the job file to use. This needs to be a Badger::Filesystem::File 
     268object. 
     269 
     270=item B<-logfile> 
     271 
     272The log file to use. This needs to be a Badger::Filesystem::File object. 
     273 
     274=item B<-rerunable> 
     275 
     276Wither the job is rerunnable, this is optional and default to no. 
     277 
     278=item B<-join_path> 
     279 
     280Wither to join stdout and stderr into one log file, this is optional 
     281and defaults to 'oe'. 
     282 
     283=item B<-account> 
     284 
     285The optional account to run under. 
     286 
     287=item B<-attributes> 
     288 
     289The optinal attributes that may be applied to this job. This should be a 
     290comma seperated list of name value pairs. 
     291 
     292=item B<-environment> 
     293 
     294The optional environment variables that may be defined for the job. This 
     295should be a comma sperated list of name value pairs. 
     296 
     297=item B<-env_export> 
     298 
     299Wither to export the users environment. 
     300 
     301=item B<-exclusive> 
     302 
     303The option to run this job exclusivily. Default is no. 
     304 
     305=item B<-hold>  
     306 
     307The option to submit this job in a hold state. 
     308 
     309=item B<-resources> 
     310 
     311Optional resources to associate with this job. This should be a comma 
     312seperated list of name value pairs. 
     313 
     314=item B<-user> 
     315 
     316The optional user account to run this job under. 
     317 
     318=item B<-host> 
     319 
     320The optional host to run this job on. 
     321 
     322=item B<-mail_points> 
     323 
     324The optional mail points that the user will be notified at. Defaults to 'bea'. 
     325 
     326=item B<-after> 
     327 
     328The optional time to run the job after. This must be a DateTime object. 
     329 
     330=item B<-shell_path> 
     331 
     332The optional path to the jobs shell. Defaults to /bin/sh. 
     333 
     334=item B<-work_path> 
     335 
     336The optional path to put work files. This must be a Badger::Filesystem::Directory.  
     337Defaults to /tmp. 
     338 
     339=item B<-priority> 
     340 
     341The optional priority to run the job at. Defaults to 0. 
     342 
     343=back 
     344 
     345=head2 qstat(...) 
     346 
     347This method returns that status of a job. This status will be a hash reference 
     348of the parsed output on stdout. It takes the following paramters: 
     349 
     350=over 4 
     351 
     352=item B<-job> 
     353 
     354The ID of the job, as returned from submit(). 
     355 
     356=item B<-host> 
     357 
     358The optional host that the job may be running on. Defaults to 'localhost'. 
     359 
     360=back 
     361 
     362=head2 qdel(...) 
     363 
     364This method will delete a job. It takes the following parameters: 
     365 
     366=over 4 
     367 
     368=item B<-job> 
     369 
     370The ID of the job, as returned from submit(). 
     371 
     372=item B<-host> 
     373 
     374The optional host that the job may be running on. Defaults to 'localhost'. 
     375 
     376=item B<-force> 
     377 
     378Wither to force the jobs deletion. Defaults to no. 
     379 
     380=item B<-message> 
     381 
     382The optional message to be placed into the log file. 
     383 
     384=back 
     385 
     386=head2 qsig(...) 
     387 
     388This method will send a signal to a job. It takes the following parameters: 
     389 
     390=over 4 
     391 
     392=item B<-job> 
     393 
     394The ID of the job, as returned from submit(). 
     395 
     396=item B<-host> 
     397 
     398The optional host that the job may be running on. Defaults to 'localhost'. 
     399 
     400=item B<-signal> 
     401 
     402The signal to send to the job.  
     403 
     404=back 
     405 
     406=head2 qhold(...) 
     407 
     408This method will place a job into a hold status. It takes the following  
     409parameters: 
     410 
     411=over 4 
     412 
     413=item B<-job> 
     414 
     415The ID of the job, as returned from submit(). 
     416 
     417=item B<-host> 
     418 
     419The optional host that the job may be running on. Defaults to 'localhost'. 
     420 
     421=item B<-type> 
     422 
     423The type of hold to place on the job. They can be any of the following: 
     424 
     425   user, other, system, none 
     426  
     427If more then one type is used, they need to be comma seperated. 
     428 
     429=back 
     430 
     431=head2 qrls(...) 
     432 
     433This method will release a job that was placed into a hold status. It takes  
     434the following parameters: 
     435 
     436=over 4 
     437 
     438=item B<-job> 
     439 
     440The ID of the job, as returned from submit(). 
     441 
     442=item B<-host> 
     443 
     444The optional host that the job may be running on. Defaults to 'localhost'. 
     445 
     446=item B<-type> 
     447 
     448The type of hold to place on the job. They can be any of the following: 
     449 
     450   user, other, system, none 
     451  
     452If more then one type is used, they need to be comma seperated. 
     453 
     454=back 
     455 
     456=head2 qmove(...) 
     457 
     458This method will move a job from one queue to another. That queue may exist on 
     459another host. It takes the following parameters: 
     460 
     461=over 4 
     462 
     463=item B<-job> 
     464 
     465The ID of the job, as returned from submit(). 
     466 
     467=item B<-queue> 
     468 
     469The queue to move the job too. 
     470 
     471=item B<-host> 
     472 
     473The optional host that the job may be running on. Defaults to 'localhost'. 
     474 
     475=item B<-dhost> 
     476 
     477The optional destination host that the queue is on. 
     478 
     479=back 
     480 
     481=head2 qmsg(...) 
     482 
     483This method will place a message into the log file of a job. It takes 
     484the following parameters: 
     485 
     486=over 4 
     487 
     488=item B<-job> 
     489 
     490The ID of the job, as returned from submit(). 
     491 
     492=item B<-host> 
     493 
     494The optional host that the job may be running on. Defaults to 'localhost'. 
     495 
     496=item B<-message> 
     497 
     498The message to be used. 
     499 
     500=item B<-output> 
     501 
     502The log to place the message, It can be one of the following: 
     503 
     504    E - stderr 
     505    O - stdout 
     506 
     507=back 
     508 
     509=head2 qrerun(...) 
     510 
     511This method will attempt to rerun a job. It takes the following parameters: 
     512 
     513=over 4 
     514 
     515=item B<-job> 
     516 
     517The ID of the job, as returned from submit(). 
     518 
     519=item B<-host> 
     520 
     521The optional host that the job may be running on. Defaults to 'localhost'. 
     522 
     523=back 
     524 
     525=head2 qalter(...) 
     526 
     527This method will alter the parameters of a job. It takes the following  
     528parameters: 
     529 
     530=over 4 
     531 
     532=item B<-job> 
     533 
     534The ID of the job, as returned from submit(). 
     535 
     536=item B<-host> 
     537 
     538The optional host that the job may be running on. Defaults to 'localhost'. 
     539 
     540=item <-jobname> 
     541 
     542This will change the jobs name. 
     543 
     544=item B<-rerunable> 
     545 
     546This will change the jobs rerunable status. 
     547 
     548=item B<-email> 
     549 
     550This will change the jobs email destinations. 
     551 
     552=item B<-account> 
     553 
     554This will change the jobs account. 
     555 
     556=item B<-attributes> 
     557 
     558This will change the optional job attributes. 
     559 
     560=item B<-exclusive> 
     561 
     562This will change wither the job has exclusive access to the server. 
     563 
     564=item B<-resources> 
     565 
     566This will change the jobs optional resources. 
     567 
     568=item B<-user> 
     569 
     570This will change the jobs user. 
     571 
     572=item B<-mail_points> 
     573 
     574This will change the jobs mail points. 
     575 
     576=item B<-shell_path> 
     577 
     578This will change the jobs shell. 
     579 
     580=item B<-hold> 
     581 
     582This will hold the job. 
     583 
     584=item B<-join_path> 
     585 
     586This will change the jobs join path. 
     587 
     588=item B<-after> 
     589 
     590This will change the time that job will run after. 
     591 
     592=item B<-out_path> 
     593 
     594This will changes the jobs output path, it must be a Badger::Filesystem::File object. 
     595 
     596=item B<-error_path> 
     597 
     598This will changes the jobs error path, it must be a Badger::Filesystem::File object. 
     599 
     600=item B<-priority> 
     601 
     602This will change the jobs priority. 
     603 
     604=back 
    220605 
    221606=head1 SEE ALSO 
     
    223608=over 4 
    224609 
     610=item L<XAS::Lib::Batch|XAS::Lib::Batch> 
     611 
    225612=item L<XAS|XAS> 
    226  
    227 =item L<XAS::Lib::Batch|XAS::Lib::Batch> 
    228613 
    229614=back 
  • trunk/lib/XAS/Lib/Batch/Queue.pm

    r96f11eb731229de55299aa08ec81c182fd951cfe re4ae52787f79097612444755cba6f78dee723cfe  
    6060=head1 SYNOPSIS 
    6161 
    62  use XAS::XXX; 
     62 use XAS::Lib::Batch::Queue; 
     63 
     64 my $queue = XAS::Lib::Batch::Queue->new(); 
     65 
     66 $queue->qstop(-queue => 'batch'); 
     67 
     68 ... 
     69 
     70 $queue->qstart(-queue => 'batch'); 
    6371 
    6472=head1 DESCRIPTION 
    6573 
     74This module provides an interface for manipulating queues in a Batch System.  
     75Each available method is a wrapper around a given command. A command line 
     76is built, executed, and the return code is checked. If the return code is 
     77non-zero an exception is thrown. The exception will include the return code 
     78and the first line from stderr. 
     79 
     80Since each method is a wrapper, there is a corresponding man page for the  
     81actual command. They should also be checked when problems arise. 
     82 
    6683=head1 METHODS 
    6784 
    68 =head2 method1 
     85=head2 new 
     86 
     87This method initializes the module and takes these parameters: 
     88 
     89=over 4 
     90 
     91=item B<-interface> 
     92 
     93The command line interface to use. This defaults to 'XAS::Lib::Batch::Interface::Torque'. 
     94 
     95=back 
     96 
     97=head2 qstat(...) 
     98 
     99This method returns that status of a queue. This status will be a hash reference 
     100of the parsed output on stdout. It takes the following paramters: 
     101 
     102=over 4 
     103 
     104=item B<-queue> 
     105 
     106The name of the queue. 
     107 
     108=item B<-host> 
     109 
     110The optional host that the queue may be on. 
     111 
     112=back 
     113 
     114=head2 qstart(...) 
     115 
     116This method start a queue. It takes the following paramters: 
     117 
     118=over 4 
     119 
     120=item B<-queue> 
     121 
     122The name of the queue. 
     123 
     124=item B<-host> 
     125 
     126The optional host that the queue may be on. 
     127 
     128=back 
     129 
     130=head2 qstop(...) 
     131 
     132This method will stop a queue. It takes the following paramters: 
     133 
     134=over 4 
     135 
     136=item B<-queue> 
     137 
     138The name of the queue. 
     139 
     140=item B<-host> 
     141 
     142The optional host that the queue may be on. 
     143 
     144=back 
     145 
    69146 
    70147=head1 SEE ALSO 
    71148 
    72149=over 4 
     150 
     151=item L<XAS::Lib::Batch|XAS::Lib::Batch> 
    73152 
    74153=item L<XAS|XAS> 
     
    82161=head1 COPYRIGHT AND LICENSE 
    83162 
    84 Copyright (c) 2014 Kevin L. Esteb 
     163Copyright (c) 2015 Kevin L. Esteb 
    85164 
    86165This is free software; you can redistribute it and/or modify it under 
  • trunk/lib/XAS/Lib/Batch/Server.pm

    r96f11eb731229de55299aa08ec81c182fd951cfe re4ae52787f79097612444755cba6f78dee723cfe  
    5656=head1 NAME 
    5757 
    58 XAS::xxx - A class for the XAS environment 
     58XAS::Lib::Batch::Server - A class for the XAS environment 
    5959 
    6060=head1 SYNOPSIS 
    6161 
    62  use XAS::XXX; 
     62 use XAS::Lib::Batch::Server; 
     63 
     64 my $server = XAS::Lib::Batch::Server->new(); 
     65 
     66 my $stat = $server->qstat(); 
    6367 
    6468=head1 DESCRIPTION 
    6569 
     70This module provides an interface for manipulating servers in a Batch System.  
     71Each available method is a wrapper around a given command. A command line 
     72is built, executed, and the return code is checked. If the return code is 
     73non-zero an exception is thrown. The exception will include the return code 
     74and the first line from stderr. 
     75 
     76Since each method is a wrapper, there is a corresponding man page for the  
     77actual command. They should also be checked when problems arise. 
     78 
    6679=head1 METHODS 
    6780 
    68 =head2 method1 
     81=head2 new 
     82 
     83This method initializes the module and takes these parameters: 
     84 
     85=over 4 
     86 
     87=item B<-interface> 
     88 
     89The command line interface to use. This defaults to 'XAS::Lib::Batch::Interface::Torque'. 
     90 
     91=back 
     92 
     93=head2 qstat(...) 
     94 
     95This method returns that status of a server. This status will be a hash  
     96reference of the parsed output on stdout. It takes the following paramters: 
     97 
     98=over 4 
     99 
     100=item B<-host> 
     101 
     102The optional host that the server may be on. Defaults to 'localhost'. 
     103 
     104=back 
     105 
     106=head2 qdisable(...) 
     107 
     108This method will disable a queue or if the queue is not given, batch processing 
     109at the server. It takes the following paramters: 
     110 
     111=over 4 
     112 
     113=item B<-queue> 
     114 
     115The optional name of the queue. 
     116 
     117=item B<-host> 
     118 
     119The optional host that the queue may be on. Defaults to 'localhost'. 
     120 
     121=back 
     122 
     123=head2 qenable(...) 
     124 
     125This method will enable a queue or if the queue is not given, batch processing 
     126at the server. It takes the following paramters: 
     127 
     128=over 4 
     129 
     130=item B<-queue> 
     131 
     132The optional name of the queue. 
     133 
     134=item B<-host> 
     135 
     136The optional host that the queue may be on. Defaults to 'localhost'. 
     137 
     138=back 
    69139 
    70140=head1 SEE ALSO 
    71141 
    72142=over 4 
     143 
     144=item L<XAS::Lib::Batch|XAS::Lib::Batch> 
    73145 
    74146=item L<XAS|XAS> 
     
    82154=head1 COPYRIGHT AND LICENSE 
    83155 
    84 Copyright (c) 2014 Kevin L. Esteb 
     156Copyright (c) 2015 Kevin L. Esteb 
    85157 
    86158This is free software; you can redistribute it and/or modify it under 
Note: See TracChangeset for help on using the changeset viewer.