view release on metacpan or  search on metacpan

bin/netdisco-backend  view on Meta::CPAN

my $netdisco = file($FindBin::RealBin, 'netdisco-backend-fg');
my @args = (scalar @ARGV > 1 ? @ARGV[1 .. $#ARGV] : ());

my $log_dir = dir($home, 'logs');
mkdir $log_dir if ! -d $log_dir;
my $log_file = file($log_dir, 'netdisco-backend.log');

my $uid = (stat($netdisco->stringify))[4] || 0;
my $gid = (stat($netdisco->stringify))[5] || 0;

my $old_pid = file($home, 'netdisco-daemon.pid');
my $new_pid = file($home, 'netdisco-backend.pid');
if (-f $old_pid) { File::Copy::move( $old_pid, $new_pid ) }

Daemon::Control->new({
  name => 'Netdisco Backend',
  program  => \&restarter,
  program_args => [@args],
  pid_file => $new_pid,
  stderr_file => $log_file,
  stdout_file => $log_file,
  redirect_before_fork => 0,
  uid => $uid, gid => $gid,
})->run;

# the guts of this are borrowed from Plack::Loader::Restarter - many thanks!!
my $child = 0;

sub restarter {
  my ($daemon, @program_args) = @_;
  $0 = 'netdisco-backend';
  $child = fork_and_start($daemon, @program_args);
  exit(1) unless $child;

  my $watcher = Filesys::Notify::Simple->new([$ENV{DANCER_ENVDIR}, $log_dir]);
  warn "config watcher: watching $ENV{DANCER_ENVDIR} for updates.\n";

  local $SIG{TERM} = sub { $child = signal_child('TERM', $child); exit(0); };

  while (1) {
      my @restart;

      # this is blocking
      $watcher->wait(sub {
          my @events = @_;
          @events = grep {$_->{path} eq $log_file or
                          file($_->{path})->basename eq $config} @events;
          return unless @events;
          @restart = @events;
      });

      my ($hupit, $rotate) = (0, 0);
      next unless @restart;

      foreach my $f (@restart) {
          if ($f->{path} eq $log_file) {
              ++$rotate;
          }
          else {
              warn "-- $f->{path} updated.\n";
              ++$hupit;
          }
      }
      $child = rotate_logs($child, $daemon, @program_args) if $rotate;
      if ($hupit) {
          signal_child('TERM', $child);
          $child = fork_and_start($daemon, @program_args);
          exit(1) unless $child;
      }
  }
}

sub fork_and_start {
  my ($daemon, @daemon_args) = @_;
  my $pid = fork;
  die "Can't fork: $!" unless defined $pid;

  if ($pid == 0) { # child
      $daemon->redirect_filehandles;
      exec( $netdisco->stringify, @daemon_args );
  }
  else {
      return $pid;
  }
}

sub signal_child {
  my ($signal, $pid) = @_;
  return unless $signal and $pid;
  warn "config watcher: sending $signal to the server (pid:$pid)...\n";
  kill $signal => $pid;
  waitpid($pid, 0);
}

sub rotate_logs {
  my $child = shift;
  return $child unless (-f $log_file) and
    ((-s $log_file) > ($logsize * 1024768));

  my @files = grep { /$log_file\.\d+/ } glob file($log_dir, '*');
  foreach my $f (sort { $b cmp $a } @files) {
      next unless $f =~ m/$log_file\.(\d+)$/;
      my $pos = $1;
      unlink $f if $pos == ($logfiles - 1);
      my $next = $pos + 1;
      (my $newf = $f) =~ s/\.$pos$/.$next/;
      rename $f, $newf;
  }

  # if the log file's about 10M then the race condition in copy/truncate
  # has a low risk of data loss. if the file's larger, then we rename and
  # kill.
  if ((-s $log_file) > (12 * 1024768)) {
      rename $log_file, $log_file .'.1';
      signal_child('TERM', $child);
      $child = fork_and_start(@_);
      if ($child){
        return $child;
      }else{
        exit(1);