Gecko [ biogenelab.eu ]

Name	Size	Permission
a2disconf	13.84 KB	-rwxr-xr-x
a2dismod	13.84 KB	-rwxr-xr-x
a2dissite	13.84 KB	-rwxr-xr-x
a2enconf	13.84 KB	-rwxr-xr-x
a2enmod	13.84 KB	-rwxr-xr-x
a2ensite	13.84 KB	-rwxr-xr-x
a2query	9.66 KB	-rwxr-xr-x
accessdb	10.13 KB	-rwxr-xr-x
accton	10.2 KB	-rwxr-xr-x
acpid	46.8 KB	-rwxr-xr-x
add-shell	695 B	-rwxr-xr-x
addgnupghome	3.05 KB	-rwxr-xr-x
addgroup	33.66 KB	-rwxr-xr-x
adduser	33.66 KB	-rwxr-xr-x
amavis-mc	18.73 KB	-rwxr-xr-x
amavis-services	33.4 KB	-rwxr-xr-x
amavisd-agent	13.11 KB	-rwxr-xr-x
amavisd-nanny	11.72 KB	-rwxr-xr-x
amavisd-new	1.46 MB	-rwxr-xr-x
amavisd-new-cronjob	825 B	-rwxr-xr-x
amavisd-release	12.32 KB	-rwxr-xr-x
amavisd-signer	36.85 KB	-rwxr-xr-x
amavisd-snmp-subagent	52.97 KB	-rwxr-xr-x
amavisd-snmp-subagent-zmq	52.42 KB	-rwxr-xr-x
amavisd-status	14 KB	-rwxr-xr-x
amavisd-submit	9.09 KB	-rwxr-xr-x
apache2	650.93 KB	-rwxr-xr-x
apache2ctl	6.25 KB	-rwxr-xr-x
apachectl	6.25 KB	-rwxr-xr-x
applygnupgdefaults	2.21 KB	-rwxr-xr-x
arp	54.38 KB	-rwxr-xr-x
arpd	39.11 KB	-rwxr-xr-x
arping	30.48 KB	-rwxr-xr-x
aspell-autobuildhash	13.09 KB	-rwxr-xr-x
atd	21.88 KB	-rwxr-xr-x
biosdecode	18.76 KB	-rwxr-xr-x
check_forensic	952 B	-rwxr-xr-x
chgpasswd	57.3 KB	-rwxr-xr-x
chpasswd	49.36 KB	-rwxr-xr-x
chroot	34.6 KB	-rwxr-xr-x
cpgr	51.48 KB	-rwxr-xr-x
cppw	51.48 KB	-rwxr-xr-x
cron	43.36 KB	-rwxr-xr-x
dbconfig-generate-include	11.63 KB	-rwxr-xr-x
dbconfig-load-include	5.57 KB	-rwxr-xr-x
delgroup	15.43 KB	-rwxr-xr-x
deluser	15.43 KB	-rwxr-xr-x
dmidecode	98.43 KB	-rwxr-xr-x
dovecot	82.05 KB	-rwxr-xr-x
dpkg-divert	135.23 KB	-rwxr-xr-x
dpkg-preconfigure	3.52 KB	-rwxr-xr-x
dpkg-reconfigure	4.23 KB	-rwxr-xr-x
dpkg-statoverride	58.84 KB	-rwxr-xr-x
dump-acct	18.46 KB	-rwxr-xr-x
dump-utmp	14.4 KB	-rwxr-xr-x
e2freefrag	10.18 KB	-rwxr-xr-x
e4defrag	26.47 KB	-rwxr-xr-x
fdformat	10.21 KB	-rwxr-xr-x
filefrag	14.25 KB	-rwxr-xr-x
groupadd	57.36 KB	-rwxr-xr-x
groupdel	53.23 KB	-rwxr-xr-x
groupmod	67.73 KB	-rwxr-xr-x
grpck	53.35 KB	-rwxr-xr-x
grpconv	49.23 KB	-rwxr-xr-x
grpunconv	49.23 KB	-rwxr-xr-x
grub-bios-setup	751.6 KB	-rwxr-xr-x
grub-install	943.7 KB	-rwxr-xr-x
grub-macbless	739.26 KB	-rwxr-xr-x
grub-mkconfig	7.78 KB	-rwxr-xr-x
grub-mkdevicemap	188.83 KB	-rwxr-xr-x
grub-probe	749.2 KB	-rwxr-xr-x
grub-reboot	4.01 KB	-rwxr-xr-x
grub-set-default	3.48 KB	-rwxr-xr-x
httxt2dbm	9.96 KB	-rwxr-xr-x
iconvconfig	30.46 KB	-rwxr-xr-x
install-sgmlcatalog	4.44 KB	-rwxr-xr-x
invoke-rc.d	15.01 KB	-rwxr-xr-x
ip6tables-apply	6.85 KB	-rwxr-xr-x
iptables-apply	6.85 KB	-rwxr-xr-x
irqbalance	43.07 KB	-rwxr-xr-x
ispell-autobuildhash	15.25 KB	-rwxr-xr-x
laptop-detect	2.53 KB	-rwxr-xr-x
ldattach	22.35 KB	-rwxr-xr-x
locale-gen	1.5 KB	-rwxr-xr-x
logrotate	62.92 KB	-rwxr-xr-x
logwatch	57.19 KB	-rwxr-xr-x
make-ssl-cert	3.69 KB	-rwxr-xr-x
mkinitramfs	9.15 KB	-rwxr-xr-x
mklost+found	10.2 KB	-rwxr-xr-x
mount.davfs	123.61 KB	-rwsr-xr-x
mysqld	11.32 MB	-rwxr-xr-x
newusers	77.86 KB	-rwxr-xr-x
nfacct	14.2 KB	-rwxr-xr-x
nfnl_osf	14.18 KB	-rwxr-xr-x
nologin	5.87 KB	-rwxr-xr-x
ownership	10.13 KB	-rwxr-xr-x
p0f-analyzer	23.34 KB	-rwxr-xr-x
pam-auth-update	19.02 KB	-rwxr-xr-x
pam_getenv	2.82 KB	-rwxr-xr-x
pam_timestamp_check	10.2 KB	-rwxr-xr-x
paperconfig	4.07 KB	-rwxr-xr-x
php5dismod	6.21 KB	-rwxr-xr-x
php5enmod	6.21 KB	-rwxr-xr-x
php5query	5.05 KB	-rwxr-xr-x
pma-configure	299 B	-rwxr-xr-x
pma-secure	157 B	-rwxr-xr-x
postalias	17.87 KB	-rwxr-xr-x
postcat	17.94 KB	-rwxr-xr-x
postconf	163.38 KB	-rwxr-xr-x
postdrop	13.99 KB	-r-xr-sr-x
postfix	13.95 KB	-rwxr-xr-x
postfix-add-filter	4.88 KB	-rwxr-xr-x
postfix-add-policy	3.81 KB	-rwxr-xr-x
postkick	9.87 KB	-rwxr-xr-x
postlock	9.87 KB	-rwxr-xr-x
postlog	10.05 KB	-rwxr-xr-x
postmap	17.87 KB	-rwxr-xr-x
postmulti	30.26 KB	-rwxr-xr-x
postqueue	13.95 KB	-r-xr-sr-x
postsuper	26.26 KB	-rwxr-xr-x
posttls-finger	33.95 KB	-rwxr-xr-x
pwck	49.3 KB	-rwxr-xr-x
pwconv	45.17 KB	-rwxr-xr-x
pwunconv	36.36 KB	-rwxr-xr-x
qmqp-sink	13.87 KB	-rwxr-xr-x
qmqp-source	17.88 KB	-rwxr-xr-x
qshape	12.55 KB	-rwxr-xr-x
readprofile	14.33 KB	-rwxr-xr-x
remove-default-ispell	2.86 KB	-rwxr-xr-x
remove-default-wordlist	2.86 KB	-rwxr-xr-x
remove-shell	749 B	-rwxr-xr-x
rmail	13.87 KB	-rwxr-xr-x
rmt	54.91 KB	-rwxr-xr-x
rmt-tar	54.91 KB	-rwxr-xr-x
rsyslogd	563.81 KB	-rwxr-xr-x
rtcwake	26.42 KB	-rwxr-xr-x
sa	35.39 KB	-rwxr-xr-x
safe_finger	10.3 KB	-rwxr-xr-x
select-default-ispell	1.83 KB	-rwxr-xr-x
select-default-wordlist	1.82 KB	-rwxr-xr-x
sendmail	26.05 KB	-rwxr-xr-x
service	9.37 KB	-rwxr-xr-x
setvesablank	10.07 KB	-rwxr-xr-x
slapacl	1.21 MB	-rwxr-xr-x
slapadd	1.21 MB	-rwxr-xr-x
slapauth	1.21 MB	-rwxr-xr-x
slapcat	1.21 MB	-rwxr-xr-x
slapd	1.21 MB	-rwxr-xr-x
slapdn	1.21 MB	-rwxr-xr-x
slapindex	1.21 MB	-rwxr-xr-x
slappasswd	1.21 MB	-rwxr-xr-x
slapschema	1.21 MB	-rwxr-xr-x
slaptest	1.21 MB	-rwxr-xr-x
smtp-sink	30.8 KB	-rwxr-xr-x
smtp-source	21.89 KB	-rwxr-xr-x
spamd	127.49 KB	-rwxr-xr-x
split-logfile	2.36 KB	-rwxr-xr-x
sshd	760.63 KB	-rwxr-xr-x
tarcat	936 B	-rwxr-xr-x
tcpd	10.12 KB	-rwxr-xr-x
tcpdchk	22.42 KB	-rwxr-xr-x
tcpdmatch	18.33 KB	-rwxr-xr-x
tcptraceroute	1.45 KB	-rwxr-xr-x
tcptraceroute.db	1.45 KB	-rwxr-xr-x
traceroute	67.37 KB	-rwxr-xr-x
try-from	10.06 KB	-rwxr-xr-x
tunelp	14.22 KB	-rwxr-xr-x
tzconfig	106 B	-rwxr-xr-x
umount.davfs	10.21 KB	-rwxr-xr-x
update-alternatives	46.43 KB	-rwxr-xr-x
update-ca-certificates	4.85 KB	-rwxr-xr-x
update-catalog	9.15 KB	-rwxr-xr-x
update-default-aspell	1 KB	-rwxr-xr-x
update-default-ispell	9.68 KB	-rwxr-xr-x
update-default-wordlist	7.5 KB	-rwxr-xr-x
update-dictcommon-aspell	1 KB	-rwxr-xr-x
update-dictcommon-hunspell	782 B	-rwxr-xr-x
update-grub	64 B	-rwxr-xr-x
update-grub2	64 B	-rwxr-xr-x
update-icon-caches	617 B	-rwxr-xr-x
update-info-dir	1.65 KB	-rwxr-xr-x
update-initramfs	8.76 KB	-rwxr-xr-x
update-locale	2.99 KB	-rwxr-xr-x
update-mime	8.84 KB	-rwxr-xr-x
update-passwd	30.31 KB	-rwxr-xr-x
update-pciids	2.84 KB	-rwxr-xr-x
update-python-modules	19.33 KB	-rwxr-xr-x
update-rc.d	11.72 KB	-rwxr-xr-x
update-xmlcatalog	16.28 KB	-rwxr-xr-x
upgrade-from-grub-legacy	1.49 KB	-rwxr-xr-x
useradd	118.69 KB	-rwxr-xr-x
userdel	81.92 KB	-rwxr-xr-x
usermod	122.5 KB	-rwxr-xr-x
validlocale	1.73 KB	-rwxr-xr-x
vcstime	6.06 KB	-rwxr-xr-x
vigr	59.73 KB	-rwxr-xr-x
vipw	59.73 KB	-rwxr-xr-x
visudo	2.2 MB	-rwxr-xr-x
vpddecode	14.26 KB	-rwxr-xr-x
vsftpd	156.32 KB	-rwxr-xr-x
zabbix_agentd	527.59 KB	-rwxr-xr-x
zic	42.36 KB	-rwxr-xr-x

Code Editor : amavisd-status

#!/usr/bin/perl -T

#------------------------------------------------------------------------------
# This is amavisd-status, a program to show status of child processes
# in amavisd-new.
#
# Author: Mark Martinec <Mark.Martinec@ijs.si>
#
# Copyright (c) 2012-2014, Mark Martinec
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright notice,
#    this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright notice,
#    this list of conditions and the following disclaimer in the documentation
#    and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and documentation are
# those of the authors and should not be interpreted as representing official
# policies, either expressed or implied, of the Jozef Stefan Institute.

# (the above license is the 2-clause BSD license, also known as
#  a "Simplified BSD License", and pertains to this program only)
#
# Patches and problem reports are welcome.
# The latest version of this program is available at:
#   http://www.ijs.si/software/amavisd/
#------------------------------------------------------------------------------

use strict;
use re 'taint';
use warnings;
use warnings FATAL => qw(utf8 void);
no warnings 'uninitialized';

use Errno qw(ESRCH ENOENT);
use POSIX qw(strftime);
use Time::HiRes ();

use vars qw($VERSION);  $VERSION = 2.008002;
use vars qw($myversion $myproduct_name $myversion_id $myversion_date);
use vars qw($outer_sock_specs);

$myproduct_name = 'amavisd-status';
$myversion_id = '2.9.0'; $myversion_date = '20140506';
$myversion = "$myproduct_name-$myversion_id ($myversion_date)";

### USER CONFIGURABLE:

# should match a socket of the same name in amavis-services
$outer_sock_specs = "tcp://127.0.0.1:23232";

### END OF USER CONFIGURABLE

use vars qw($zmq_mod_name $zmq_mod_version $zmq_lib_version);
BEGIN {
  my($zmq_major, $zmq_minor, $zmq_patch);
  if (eval { require ZMQ::LibZMQ3 && require ZMQ::Constants }) {
    $zmq_mod_name = 'ZMQ::LibZMQ3';  # new interface module to zmq v3 or libxs
    import ZMQ::LibZMQ3;  import ZMQ::Constants qw(:all);
    ($zmq_major, $zmq_minor, $zmq_patch) = ZMQ::LibZMQ3::zmq_version();
  # *zmq_sendmsg   [native]                   # (socket,msgobj,flags)
  # *zmq_recvmsg   [native]                   # (socket,flags) -> msgobj
    *zmq_sendstr = sub {                      # (socket,string,flags)
      my $rv = zmq_send($_[0], $_[1], length $_[1], $_[2]||0);
      $rv == -1 ? undef : $rv;
    };
  } elsif (eval { require ZMQ::LibZMQ2 && require ZMQ::Constants }) {
    $zmq_mod_name = 'ZMQ::LibZMQ2';  # new interface module to zmq v2
    import ZMQ::LibZMQ2;  import ZMQ::Constants qw(:all);
    ($zmq_major, $zmq_minor, $zmq_patch) = ZMQ::LibZMQ2::zmq_version();
    # zmq v2/v3 incompatibile renaming
    *zmq_sendmsg = \&ZMQ::LibZMQ2::zmq_send;  # (socket,msgobj,flags)
    *zmq_recvmsg = \&ZMQ::LibZMQ2::zmq_recv;  # (socket,flags) -> msgobj
    *zmq_sendstr = sub {                      # (socket,string,flags)
      my $rv = zmq_send(@_);  $rv == -1 ? undef : $rv;
    };
  } elsif (eval { require ZeroMQ::Constants && require ZeroMQ::Raw }) {
    $zmq_mod_name = 'ZeroMQ';  # old interface module to zmq v2
    import ZeroMQ::Raw;  import ZeroMQ::Constants qw(:all);
    ($zmq_major, $zmq_minor, $zmq_patch) = ZeroMQ::version();
    # zmq v2/v3 incompatibile renaming
    *zmq_sendmsg = \&ZeroMQ::Raw::zmq_send;   # (socket,msgobj,flags)
    *zmq_recvmsg = \&ZeroMQ::Raw::zmq_recv;   # (socket,flags) -> msgobj
    *zmq_sendstr = sub {                      # (socket,string,flags)
      my $rv = zmq_send(@_);  $rv == -1 ? undef : $rv;
    };
  } else {
    die "Perl modules ZMQ::LibZMQ3 or ZMQ::LibZMQ2 or ZeroMQ not available\n";
  }
  $zmq_mod_version = $zmq_mod_name->VERSION;
  $zmq_lib_version = join('.', $zmq_major, $zmq_minor, $zmq_patch);
  1;
}

sub zmq_version {
  sprintf("%s %s, lib %s",
          $zmq_mod_name, $zmq_mod_version, $zmq_lib_version);
};

sub zmq_recvstr {               # (socket,buffer,offset) -> (len,more)
  my $sock = $_[0];
  my $offset = $_[2] || 0;
  my $zm = zmq_recvmsg($sock);  # a copy of a received msg obj
  if (!$zm) { substr($_[1],$offset) = ''; return }
  ($offset ? substr($_[1],$offset) : $_[1]) = zmq_msg_data($zm);
  my $len = length($_[1]) - $offset;
  zmq_msg_close($zm);
  return $len  if !wantarray;
  my $more = zmq_getsockopt($sock, ZMQ_RCVMORE);
  if ($more == -1) { substr($_[1],$offset) = ''; return }
  ($len, $more);
};

my $wakeuptime = 1;    # -w, sleep time in seconds, may be fractional
my $repeatcount;       # -c, repeat count (when defined)

my $zmq_poll_units = 1000;  # milliseconds since zmq v3
$zmq_poll_units *= 1000  if $zmq_lib_version =~ /^[012]\./;  # microseconds

sub fmt_age($$$) {
  my($t,$state_bar,$idling) = @_;
  $t = int($t);
  my $char = $idling ? '.' : '=';
  my $bar_l = $idling ? $t : length($state_bar);
  my $bar = substr( ($char x 9 . ':') x 3 . $char x 5, 0,$bar_l);
  if (!$idling) {
    $state_bar = substr($state_bar,0,length($bar)-2) . substr($state_bar,-1,1)
                 . '>'  if length($state_bar) > length($bar);
    for my $j (0 .. length($bar)-1) {
      substr($bar,$j,1) = substr($state_bar,$j,1)
        if substr($bar,$j,1) eq '=' && substr($state_bar,$j,1) ne ' ';
    }
  }
  my $s = $t % 60;  $t = int($t/60);
  my $m = $t % 60;  $t = int($t/60);
  my $h = $t % 24;  $t = int($t/24);
  my $d = $t;
  my $str = sprintf("%d:%02d:%02d", $h,$m,$s);
  $str = (!$d ? "  " : sprintf("%dd",$d)) . $str;
  $str . ' ' . $bar;
};

sub usage() {
  print <<'EOD';
States legend:
  A  accepted a connection
  b  begin with a protocol for accepting a request
  m  'MAIL FROM' smtp command started a new transaction in the same session
  d  transferring data from MTA to amavisd
  =  content checking just started
  G  generating and verifying unique mail_id
  D  decoding of mail parts
  V  virus scanning
  S  spam scanning
  P  pen pals database lookup and updates
  r  preparing results
  Q  quarantining and preparing/sending notifications
  F  forwarding mail to MTA
  .  content checking just finished
  sp space indicates idle (elapsed time bar is showing dots)

EOD
  print "Usage: $0 [-c <count>] [-w <wait-interval>]\n";
}

my($zmq_ctx, $zmq_sock);
my %process; # associative array on pid
my $any_events = 0;

sub process_message {
  my($msgstr, $msgstr_l, $more, $val, $p);
  for (;;) {
    ($msgstr_l,$more) = zmq_recvstr($zmq_sock,$msgstr);
    defined $msgstr_l  or die "zmq_recvstr failed: $!";
    $any_events = 1;
    local($1);
    if (!defined $msgstr) {
      # should not happen (except on a failure of zmq_recvmsg)
    } elsif ($msgstr =~ /^am\.st \d+\s+/s) {
      my($subscription_chan, $pid, $time, $state, $task_id) =
        split(' ',$msgstr);
      if ($state eq 'FLUSH') {
        %process = ();  # flush all kept state (e.g. on a restart)
        printf STDERR ("state flushed (restart)\n");
      } elsif ($state eq 'exiting' || $state eq 'purged') {
        delete $process{$pid};  # may or may not exist
      } else {
        $state = ' ' if $state eq '-';
        $p = $process{$pid};
        if ($p) {
          $p->{state} = $state;
          $p->{task_id} = $task_id;
        } else {  # new process appeared
          $process{$pid} = $p = {
            state     => $state,
            task_id   => $task_id,
            timestamp => undef,
            base_timestamp => undef,
            last_displ_timestamp => undef,
            state_bars => undef,
          };
        }
        my $now = Time::HiRes::time;
        if ($time > 1e9) {  # Unix time in seconds with fraction (> Y2000)
          $p->{base_timestamp} = $p->{timestamp} = $time;
          $p->{state_bars} = '';  # reset for a new task
        } elsif (!$p->{base_timestamp}) {  # delta time but no base
          $p->{timestamp} = $now;
          $p->{base_timestamp} = $p->{timestamp} - $time/1000;  # estimate
        } else {  # delta time in ms since base_timestamp
          $p->{timestamp} = $p->{base_timestamp} + $time/1000;
        }
        $p->{tick} = $now;
      }
    } elsif ($msgstr =~ /^am\.proc\.(busy|idle) /) {
      my($subscription_chan, @pid_list) = split(' ',$msgstr);
      my $now = Time::HiRes::time;
      for my $pid (@pid_list) {
        if ($process{$pid}) {
          $p->{tick} = $now;
        } else {
          $process{$pid} = $p = {
            state => $1 eq 'busy' ? '?' : ' ',
            base_timestamp => $now, timestamp => $now, tick => $now,
          };
        }
      }
    } else {
      print STDERR "Unrecognized message received: $msgstr\n";
    }
    last if !$more;
  }
  1;
}

use vars qw($peak_active $last_peak_reading_time);
BEGIN { $peak_active = 0 }
sub display_state() {
  my $num_idling = 0;
  my $num_active = 0;
  my $now = Time::HiRes::time;
  for my $pid (sort { $a <=> $b } keys %process) {
    my $p = $process{$pid};
    my $idling = !defined $p->{task_id} && $p->{state} =~ /^[. ]\z/s;
    my $age = $now - $p->{base_timestamp};
    if ($idling) {
      $num_idling++;
      $p->{state_bars} = '';
      next;  # suppress reporting idle processes (or comment-out)
    } else {
      $num_active++;
      my $len = int($age + 0.5);
      $len = 1  if $len < 1;
      my $str = $p->{state_bars};
      $str = ''  if !defined $str;
      if ($len > length $str) {  # replicate last character to desired size
        my $ch = $str eq '' ? '=' : substr($str,-1,1);
        $str .= $ch x ($len - length $str);
      }
      substr($str,$len-1,1) = $p->{state};
      $p->{state_bars} = $str;
    }
    printf STDERR ("PID %5d: %-11s %s\n",
                   $pid, $p->{task_id} || $p->{state},
                   fmt_age($age, $p->{state_bars}, $idling) );
  }
  $now = Time::HiRes::time;
  if ($num_active > $peak_active) {
    $peak_active = $num_active;
  } elsif ($peak_active >= 0.1) {  # exponential decay of a peak indicator
    my $halflife = 8;  # seconds
    my $weight = exp(-(($now - $last_peak_reading_time) / $halflife) * log(2));
    $peak_active *= $weight;
    $peak_active = $num_active  if $num_active > $peak_active;
  }
  $last_peak_reading_time = $now;
  my $bar = ('*' x $num_active) . ('.' x $num_idling);
  my $ipeak_active = int($peak_active+0.5);
  if ($ipeak_active > $num_active) {
    $bar .= ' ' x ($ipeak_active - ($num_active + $num_idling));
  # substr($bar, $ipeak_active-1, 1) = '|';
    substr($bar, $num_active, $ipeak_active-$num_active) =
      ':' x ($ipeak_active-$num_active)  if $ipeak_active > $num_active;
  }
  printf STDERR ("%d active, %d idling processes\n", $num_active, $num_idling);
  printf STDERR ("%s\n", $bar);
}

# main program starts here

my $normal_termination = 0;
  $SIG{INT}  = sub { die "\n" };  # do the END code block when interrupted
  $SIG{TERM} = sub { die "\n" };  # do the END code block when killed

while (@ARGV) {
    my $opt = shift @ARGV;
    my $val = shift @ARGV;
    if ($opt eq '-w' && $val =~ /^\+?\d+(?:\.\d*)?\z/) { $wakeuptime = $val }
    elsif ($opt eq '-c' && $val =~ /^[+-]?\d+\z/) { $repeatcount = $val }
    else { usage(); exit 1 }
  }

$zmq_ctx = zmq_init();
  $zmq_ctx or die "Can't create ZMQ context: $!";
  $zmq_sock = zmq_socket($zmq_ctx,ZMQ_SUB);
  $zmq_sock or die "Can't create ZMQ socket: $!";

my $sock_ipv4only = 1;  # a ZMQ default
  if (defined &ZMQ_IPV4ONLY && $outer_sock_specs =~ /:[0-9a-f]*:/i) {
    zmq_setsockopt($zmq_sock, ZMQ_IPV4ONLY(), 0) != -1
      or die "zmq_setsockopt failed: $!";
    $sock_ipv4only = 0;
  }
  zmq_setsockopt($zmq_sock, ZMQ_SUBSCRIBE, 'am.st ') != -1
    or die "zmq_setsockopt SUBSCRIBE failed: $!";
  zmq_setsockopt($zmq_sock, ZMQ_SUBSCRIBE, 'am.proc.') != -1
    or die "zmq_setsockopt SUBSCRIBE failed: $!";

zmq_connect($zmq_sock, $outer_sock_specs) != -1
    or die "zmq_connect to $outer_sock_specs failed: $!";

print <<'EOD';
process-id task-id     elapsed in    elapsed-bar (dots indicate idle)
           or state   idle or busy
EOD

my $last_display_time;
  for (;;) {
    if (defined $repeatcount) {
      last  if $repeatcount <= 0;
      $repeatcount--;
    }
    $| = 0;
    print "\n";

my $now = Time::HiRes::time;
    my $redraw_at =
      defined $last_display_time ? $last_display_time + $wakeuptime
                                 : $now + 0.2;
    for (;;) {
      my $timeout = $redraw_at - $now;
      $timeout = 0  if $timeout < 0;
      $any_events = 0;
      zmq_poll(
        [
          { socket => $zmq_sock,
            events => ZMQ_POLLIN,
            callback => \&process_message,
          },
        ],
        $timeout * $zmq_poll_units
      ) != -1  or die "zmq_poll failed: $!";
      $now = Time::HiRes::time;
      last if $now >= $redraw_at;
      last if $any_events && $now > $last_display_time + 0.2;
    }

while (my($pid,$p) = each %process) {  # remove stale entries
      delete $process{$pid}  if $p && $now - $p->{tick} > 10*60;
    }
    display_state();
    $last_display_time = Time::HiRes::time;

$| = 1;  # flush STDOUT
  } # forever

$normal_termination = 1;

END {
  # ignoring status
  zmq_close($zmq_sock) if $zmq_sock;
  zmq_term($zmq_ctx)   if $zmq_ctx;
  print "exited\n" if !$normal_termination;

close(STDOUT) or die "Error closing STDOUT: $!";
  close(STDERR) or die "Error closing STDERR: $!";
}

${this.title}

Code Editor : amavisd-status