Changeset 2289ce27d5d41d4e866f59c98e2fe79f9ac757dd in xas


Ignore:
Timestamp:
05/23/16 09:04:56 (4 years ago)
Author:
Kevin L. Esteb <kevin@…>
Branches:
master
Children:
886ddb8cd6b59a2d1f0dd8fd45d001215679b984
Parents:
60cb90fa3396f78e31f9b676ed9a2ecf7292144e
git-author:
Kevin L. Esteb <kevin@…> (05/23/16 09:04:56)
git-committer:
Kevin L. Esteb <kevin@…> (05/23/16 09:04:56)
Message:

Fixed a few problems and add some features

Location:
trunk/lib/XAS/Lib
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/XAS/Lib/POE/Session.pm

    ra092c5f1d1a24626693f77a88724db6c6f78546b r2289ce27d5d41d4e866f59c98e2fe79f9ac757dd  
    155155    } 
    156156 
    157 #    $poe_kernel->sig('DIE', 'session_exception'); 
     157    $poe_kernel->sig('DIE', 'session_exception'); 
    158158    $poe_kernel->post($alias, 'session_init'); 
    159159 
     
    244244 
    245245        $self->log->debug(sprintf('%s: sending execption to: %s', $alias, $ex->{'source_session'})); 
    246         $poe_kernel->signal($ex->{'source_session'}, 'DIE', $sig, $ex); 
     246        $poe_kernel->post($ex->{'source_session'}, 'session_exception', $sig, $ex); 
    247247 
    248248    } else { 
    249249 
    250         $self->log->debug(sprintf('%s: handling execption', $alias)); 
     250        $self->log->debug(sprintf('%s: handling execption: %s', $alias, $ex->{'error_str'})); 
    251251        $self->session_exception($ex->{'error_str'}); 
    252252 
  • trunk/lib/XAS/Lib/Spawn.pm

    rb122fdcbf336f69e24c9ad7b801ef98c00a2266b r2289ce27d5d41d4e866f59c98e2fe79f9ac757dd  
    1616  version   => $VERSION, 
    1717  base      => 'XAS::Base', 
    18   mixin     => $mixin, 
     18  mixin     => "WPM::Lib::Mixin::Process $mixin", 
    1919  utils     => 'dotid trim', 
    2020  accessors => 'merger', 
     
    205205Start the process. It returns the pid of that process. 
    206206 
     207=head2 status 
     208 
     209Returns the status of the process. The status could be one of the follow: 
     210 
     211=over 4 
     212 
     213=item 6 - suspended ready 
     214 
     215=item 5 - suspended blocked 
     216 
     217=item 4 - blocked 
     218 
     219=item 3 - running 
     220 
     221=item 2 - ready 
     222 
     223=item 1 - other 
     224 
     225=item 0 - unknown 
     226 
     227=back 
     228 
     229=head2 pause 
     230 
     231Pause the process, returns 1 on success. 
     232 
     233=head2 resume 
     234 
     235Resume the process, returns 1 on success. 
     236 
     237=head2 stop 
     238 
     239Stop the process, returns 1 on success. 
     240 
     241=head2 kill 
     242 
     243Kill the process, returns 1 on success. 
     244 
     245=head2 wait 
     246 
     247Waits for the process to finish, returns 0 when the process is done. 
     248This method may return a -1 if the processes was reaped before the 
     249wait is called. 
     250 
     251=head2 errorlevel 
     252 
     253Returns the exit code of the process, or a -1 if the exit code is not 
     254available. 
     255 
    207256=head1 SEE ALSO 
    208257 
     
    225274=head1 COPYRIGHT AND LICENSE 
    226275 
    227 Copyright (c) 2012-2015 Kevin L. Esteb 
     276Copyright (c) 2012-2016 Kevin L. Esteb 
    228277 
    229278This is free software; you can redistribute it and/or modify it under 
  • trunk/lib/XAS/Lib/Spawn/Unix.pm

    rdce35efa3f76dfd1228f178bcf814d864815e4de r2289ce27d5d41d4e866f59c98e2fe79f9ac757dd  
    33our $VERSION = '0.01'; 
    44 
    5 use POSIX qw(setsid); 
     5use POSIX qw(:errno_h :sys_wait_h); 
    66 
    77use XAS::Class 
    88  version => $VERSION, 
    99  base    => 'XAS::Base', 
    10   utils   => ':env dotid compress trim', 
    11   mixins  => 'run _parse_command', 
     10  utils   => ':env dotid compress trim exitcode', 
     11  mixins  => 'run stop status pause resume wait _parse_command', 
    1212; 
    1313 
     
    8181 
    8282        return $pid; 
     83 
     84} 
     85 
     86sub status { 
     87    my $self = shift; 
     88 
     89    my $stat = 0; 
     90 
     91    if ($self->pid) { 
     92 
     93                my $pid = $self->pid; 
     94 
     95        $stat = $self->proc_status($pid); 
     96 
     97    } 
     98 
     99    return $stat; 
     100 
     101} 
     102 
     103sub pause { 
     104    my $self = shift; 
     105 
     106        my $stat = 0; 
     107    my $alias = $self->alias; 
     108 
     109    if ($self->pid) { 
     110 
     111        my $pid = ($self->pid * -1); 
     112        my $code = $self->status(); 
     113 
     114        if (($code == 3) || ($code == 2)) {   # process is running or ready 
     115 
     116            if (kill('STOP', $pid)) { 
     117 
     118                                $stat = 1; 
     119 
     120            } 
     121 
     122        } 
     123 
     124    } 
     125 
     126        return $stat; 
     127 
     128} 
     129 
     130sub resume { 
     131    my $self = shift; 
     132 
     133        my $stat = 0; 
     134 
     135    if ($self->pid) { 
     136 
     137        my $pid = ($self->pid * -1); 
     138        my $code = $self->status(); 
     139 
     140        if ($code == 6) {   # process is suspended ready 
     141 
     142            if (kill('CONT', $pid)) { 
     143 
     144                                $stat = 1; 
     145 
     146            } 
     147 
     148        } 
     149 
     150    } 
     151 
     152        return $stat; 
     153 
     154} 
     155 
     156sub stop { 
     157    my $self = shift; 
     158 
     159        my $stat = 0; 
     160 
     161    if ($self->pid) { 
     162 
     163        my $pid = ($self->pid * -1); 
     164 
     165        if (kill('TERM', $pid)) { 
     166 
     167                        $stat = 1; 
     168 
     169        } 
     170 
     171    } 
     172 
     173        return $stat; 
     174 
     175} 
     176 
     177sub kill { 
     178    my $self = shift; 
     179 
     180    my $stat = 0; 
     181 
     182    if ($self->pid) { 
     183 
     184        my $pid = ($self->pid * -1); 
     185 
     186        if (kill('KILL', $pid)) { 
     187 
     188                        $stat = 1; 
     189 
     190        } 
     191 
     192    } 
     193 
     194        return $stat; 
     195 
     196} 
     197 
     198sub wait { 
     199        my $self = shift; 
     200 
     201        my $stat = 0; 
     202 
     203        if (my $pid = $self->pid) { 
     204 
     205                sleep(1);    # emulate the 1000ms wait in the Win32 mixin 
     206 
     207                # Try to wait on the process. 
     208 
     209                my $result = waitpid($pid, WNOHANG); 
     210 
     211                if ($result == $pid) { 
     212 
     213                        # Process finished.  Grab the exit value. 
     214 
     215                        my ($rc, $sig) = exitcode(); 
     216 
     217                        $self->{'errorlevel'} = $rc; 
     218                        $self->{'pid'} = 0; 
     219 
     220                } elsif ($result == -1 and $! == ECHILD) { 
     221 
     222                        # Process already reaped.  We don't know the exist status. 
     223 
     224                        $self->{'errorlevel'} = -1; 
     225                        $self->{'pid'} = 0; 
     226         
     227                } else { 
     228 
     229                        # Process still running 
     230 
     231                        $stat = 1; 
     232 
     233                } 
     234 
     235        } 
     236 
     237        return $stat; 
    83238 
    84239} 
     
    145300=head1 COPYRIGHT AND LICENSE 
    146301 
    147 Copyright (c) 2012-2015 Kevin L. Esteb 
     302Copyright (c) 2012-2016 Kevin L. Esteb 
    148303 
    149304This is free software; you can redistribute it and/or modify it under 
  • trunk/lib/XAS/Lib/Spawn/Win32.pm

    rdce35efa3f76dfd1228f178bcf814d864815e4de r2289ce27d5d41d4e866f59c98e2fe79f9ac757dd  
    33our $VERSION = '0.01'; 
    44 
    5 use Win32; 
    65use Win32::Process; 
    76 
     
    109  base    => 'XAS::Base', 
    1110  utils   => ':env dotid compress', 
    12   mixins  => 'run _parse_command', 
     11  mixins  => 'run stop status pause resume wait _parse_command', 
    1312; 
    1413 
     
    8079 
    8180    return $process->GetProcessID(); 
     81 
     82} 
     83 
     84sub status { 
     85    my $self = shift; 
     86 
     87    my $stat = 0; 
     88 
     89    if ($self->pid) { 
     90 
     91        my $pid = $self->pid; 
     92 
     93        $stat = $self->proc_status($pid); 
     94 
     95    } 
     96 
     97    return $stat; 
     98 
     99} 
     100 
     101sub pause { 
     102    my $self = shift; 
     103 
     104    my $stat = 0; 
     105 
     106    if ($self->pid) { 
     107 
     108        my $code = $self->status(); 
     109 
     110        if (($code == 3) || ($code == 2)) {   # process is running or ready 
     111 
     112            $self->process->Suspend(); 
     113            $stat = 1; 
     114 
     115        } 
     116 
     117    } 
     118 
     119    return $stat; 
     120 
     121} 
     122 
     123sub resume { 
     124    my $self = shift; 
     125     
     126    my $stat = 0; 
     127 
     128    if ($self->pid) { 
     129 
     130        my $code = $self->status(); 
     131 
     132        if ($code == 6) { 
     133 
     134            $self->process->Resume(); 
     135            $stat = 1; 
     136 
     137        } 
     138 
     139    } 
     140 
     141    return $stat; 
     142 
     143} 
     144 
     145sub stop { 
     146    my $self = shift; 
     147 
     148    my $stat = 0; 
     149 
     150    if ($self->pid) { 
     151 
     152        my $exitcode; 
     153        my $pid = $self->pid; 
     154 
     155        Win32::Process::KillProcess($pid, $exitcode); 
     156 
     157    } 
     158 
     159    return $stat; 
     160 
     161} 
     162 
     163sub kill { 
     164    my $self = shift; 
     165 
     166    return $self->stop(); 
     167 
     168} 
     169 
     170sub wait { 
     171    my $self = shift; 
     172 
     173    my $stat = 0; 
     174 
     175    if (my $pid = $self->pid) { 
     176 
     177        # Try to wait on the process. 
     178 
     179        my $result = $self->process->Wait(1000); 
     180 
     181        if ($result == 1) { 
     182 
     183            # Process finished.  Grab the exit value. 
     184 
     185            my $exitcode; 
     186            $self->process->GetExitCode($exitcode); 
     187 
     188            $self->{'errorlevel'} = ($exitcode * 256) >> 8; 
     189            $self->{'pid'} = 0; 
     190 
     191        } elsif ($result == 0) { 
     192 
     193            # Process still running. 
     194 
     195            $stat = 1; 
     196 
     197        } 
     198 
     199    } 
     200 
     201    return $stat; 
    82202 
    83203} 
     
    174294=head1 COPYRIGHT AND LICENSE 
    175295 
    176 Copyright (c) 2012-2015 Kevin L. Esteb 
     296Copyright (c) 2012-2016 Kevin L. Esteb 
    177297 
    178298This is free software; you can redistribute it and/or modify it under 
Note: See TracChangeset for help on using the changeset viewer.