| Current Path : /home/thomas/public_html/Fox-C404/root/scripts/ |
| Current File : /home/thomas/public_html/Fox-C404/root/scripts/try-later |
#!/usr/local/cpanel/3rdparty/bin/perl
# cpanel - scripts/try-later Copyright 2011 cPanel, Inc.
# All rights Reserved.
# copyright@cpanel.net http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
use strict;
use warnings;
use Cpanel::Alarm ();
use Cpanel::FindBin ();
use Cpanel::SafeRun::Errors ();
use Cpanel::Usage ();
use DateTime ();
use IPC::Open3 ();
use Cpanel::Version::Full ();
my $act_finally;
my $action_command;
my $at_args;
my $check_command;
my $delay = 5;
my $max_retries;
my $skip_first;
my $has_jobs;
my $at_cmd = Cpanel::FindBin::findbin('at');
my $atd_cmd = Cpanel::FindBin::findbin('atd');
if ( !$at_cmd || !$atd_cmd ) {
print_usage_and_exit('System "at" command required to run this utility.');
}
Cpanel::Usage::wrap_options(
\@ARGV,
\&print_usage_and_exit,
{
'act-finally' => \$act_finally,
'action' => \$action_command,
'at' => \$at_args,
'check' => \$check_command,
'delay' => \$delay,
'max-retries' => \$max_retries,
'skip-first' => \$skip_first,
'has-jobs' => \$has_jobs,
},
);
if ($has_jobs) {
# exit 0 : queue is empty
# exit 1 : queue has at least one job
exit try_later_has_jobs();
}
if ( !$action_command ) {
print_usage_and_exit('An action command is required.');
}
if ( !$check_command ) {
print_usage_and_exit('A check command is required');
}
# The extra parens are necessary.
if ( $max_retries && ( $max_retries !~ m/^\d+$/ || $max_retries < 1 ) ) {
print_usage_and_exit('Invalid value for --max-retries');
}
# if we're skipping running the check immediately, then
# we need to add a retry as it is decremented during
# do_later
if ( $skip_first && $max_retries ) {
++$max_retries;
}
if ( $delay && $delay =~ m/^\d+$/ && $delay > 0 ) {
# at seems to subtract a minute from the now +, so adding
# an extra minute seems to make it more understandable
++$delay;
$at_args = "now + $delay minutes";
}
elsif ($delay) {
print_usage_and_exit('Invalid value for --delay');
}
check() unless $skip_first;
if ( $max_retries == 1 ) {
if ($act_finally) {
exit run_command($action_command);
}
exit;
}
if ( !start_atd() ) {
print "Unable to start 'atd', which is required to run this utility.\n";
exit 1;
}
do_later();
sub check {
if ( run_command($check_command) ) {
return;
}
exit run_command($action_command);
}
sub do_later {
my %arg_for_name = (
'--act-finally' => $act_finally,
'--action' => $action_command,
'--at' => $at_args,
'--check' => $check_command,
);
my $me = '/usr/local/cpanel/scripts/try-later';
# during a fast upgrade / downgrade we could disappear
# we should empty the at queue before upgrading or downgrading
exit unless -x $me;
my @self_command = ($me);
if ($max_retries) {
--$max_retries;
push @self_command, '--max-retries', $max_retries;
}
while ( my ( $name, $arg ) = each %arg_for_name ) {
next if !length $arg;
push @self_command, $name, "'$arg'";
}
my ( $wh, $rh );
my $pid = IPC::Open3::open3( $wh, $rh, $rh, "$at_cmd $at_args" );
# used to identify jobs in queue
# could be used to clean the at queue when launching an upgrade
print {$wh} _job_tag() . "\n";
# protection wrapped when the job will be launched ( should be ok in 99 % of cases, even if a race condition exists )
print {$wh} "if [ -x $me ]; then \n";
print {$wh} join( ' ', @self_command ), "\n";
print {$wh} "fi\n";
close $wh;
close $rh;
waitpid $pid, 0;
exit $? >> 8;
}
sub start_atd {
# Before we start atd, we need to check for stale jobs so that if atd has
# been disabled, we don't unleash an angry horde of ancient jobs on the
# system when we re-enable it.
my $alarm = Cpanel::Alarm->new( 60, sub { print "Unable to start 'atd' (required for try-later)\n"; exit 1; } );
my $atq_cmd = Cpanel::FindBin::findbin('atq');
my $atrm_cmd = Cpanel::FindBin::findbin('atrm');
my @jobs;
my @check_cmd = (
'/usr/local/cpanel/scripts/cpservice',
'atd',
'status'
);
return if !-x $check_cmd[0];
# Don't bother starting atd if it's already running.
Cpanel::SafeRun::Errors::saferunnoerror(@check_cmd);
return 1 unless $?;
return unless $atq_cmd;
open( my $fh, '-|', $atq_cmd );
while ( defined( my $line = <$fh> ) ) {
next unless $line =~ m/(\d+)\s+(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})/;
push @jobs, $1 if DateTime->new( year => $2, month => $3, day => $4, hour => $5, minute => $6 ) <= DateTime->now();
}
close($fh);
if (@jobs) {
return unless $atrm_cmd;
return if system( $atrm_cmd, @jobs );
}
my @enable_cmd = (
'/usr/local/cpanel/scripts/cpservice',
'atd',
'enable'
);
return if !-x $enable_cmd[0];
# Sometimes if atd exits uncleanly (e.g. with kill -9), simply trying to
# start it won't work. This is true of CentOS 5, but not CentOS 6. So
# instead, we call restart to stop it first to make sure that all the
# appropriate state is cleaned up, and then start it again.
my @start_cmd = (
'/usr/local/cpanel/scripts/cpservice',
'atd',
'restart'
);
return if !-x $start_cmd[0];
return if system @enable_cmd;
return !system @start_cmd;
}
sub _job_tag {
return "# cPanel try-later version " . Cpanel::Version::Full::getversion();
}
sub try_later_has_jobs {
my @results = Cpanel::SafeRun::Errors::saferunallerrors( Cpanel::FindBin::findbin('atq') );
foreach (@results) {
next unless $_ =~ /^(\d+)/;
my $jid = $1;
my $job = Cpanel::SafeRun::Errors::saferunallerrors( $at_cmd, '-c', $jid );
my $tag = _job_tag();
my $regexp = qr{$tag};
return 1 if $job =~ /^$regexp/m;
}
return 0;
}
# This function exists because we may be running under atd. If we are, and we
# produce output of any sort, the system administrator will receive an email
# entitled "Output from your job", which will only serve to confuse them.
# Consequently, we suppress all output here.
sub run_command {
my ($command) = @_;
local *STDOUT = *STDOUT;
local *STDERR = *STDERR;
open( STDOUT, ">", "/dev/null" ) or die;
open( STDERR, ">", "/dev/null" ) or die;
return system($command);
}
sub print_usage_and_exit {
my ($error) = @_;
my %options = (
'act-finally' => 'Perform action when retries run out',
'action' => 'Command to run when a check succeeds',
'at' => 'Args to specify when the at command will retry the check',
'check' => 'Command to run to check whether or not to run the action',
'delay' => 'Specify a delay in minutes after which to check and act (default 5)',
'help' => 'Brief help message',
'max-retries' => 'Maximum attempts to retry before giving up (default infinite)',
'skip-first' => 'Skip the first check command',
'has-jobs' => 'Check if the try-later queue is empty or not ( exit with 0 if queue is empty )'
);
if ( defined $error ) {
print $error, "\n\n";
}
print "Usage: $0 ";
print "[options]\n\n";
print " Options:\n";
while ( my ( $opt, $desc ) = each %options ) {
print " --$opt";
my $space = 12 - length $opt;
( 0 < $space ) ? print ' ' x $space : print ' ';
print "$desc\n";
}
print "\n";
print "This utility will execute a check command at the configured interval. If the\n";
print "check command returns in error, it will be retried later as often as allowed by\n";
print "max-retries. When the check succeeds, the action command will be run.";
print "\n";
exit 1 if defined $error;
exit;
}
Copyright 2K16 - 2K18 Indonesian Hacker Rulez
;?>)