4.0.0alpha.svn.7719
Amanda modules list
List of All Modules
All Amanda Releases

Amanda::Status

NAME

Amanda::Status -- Get the status of a running job.

SYNOPSIS

    use Amanda::Status;

 filename      => The amdump file used for this status
 dead_run      => 1 if the run is already finished/killed
                  0 if the run is running
 datestamp     => $datestamp "20080618130147"
 idle_dumpers  => number of idle dumpers
 status_driver => status of the driver
                    not-idle               working
                    no-dumpers             all dumpers active
                    start-wait             waiting for the startime of a dle
                    no-hold                dle with no holding disk, taper busy
                    client-constrained     can't open new connection to the client
                                             because of maxdumps or spindle
                    no-bandwidth           no bandwidth available
                    no-diskspace           no holding disk space
 network_free_kps   => free network bandwidth
 holding_free_space => free holding disk space
 holding_space => total holding disk space
 starttime     => The time at start of job since epoc (1213808507)
 current_time  => The current time since starttime in second (12.34)
 exit_status   => The exit status
                  0  = success
                  1  = error
                  4  = a dle failed
                  8  = Don't know the status of a dle (RESULT_MISSING in the report)
                  16 = tape error or no more tape
 dles->{$host}->{$disk}->{$datestamp}->{'status'}            => $status
                                                                  $IDLE                    default
                                                                  $ESTIMATING              got no estimate result yet
                                                                  $ESTIMATE_PARTIAL        got estimate for a few level
                                                                  $ESTIMATE_FAILED         estimate failed
                                                                  $ESTIMATE_DONE           got estimate for all levels
                                                                  $WAIT_FOR_DUMPING        wait for dumping
                                                                  $DUMPING_INIT            dumping initialization phase
                                                                  $DUMPING                 dumping
                                                                  $DUMPING_DUMPER          dumping ending phase
                                                                  $DUMP_DONE               dump done and succeeded
                                                                  $DUMP_FAILED             dump failed
                                                                  $DUMPING_TO_TAPE_INIT    dumping to tape initialisation phase
                                                                  $DUMPING_TO_TAPE         dumping to tape
                                                                  $DUMPING_TO_TAPE_DUMPER  dumping to tape ending phase
                                                                  $DUMP_TO_TAPE_DONE       dump done and succeeded
                                                                  $DUMP_TO_TAPE_FAILED     dump to tape failed
                                       {'level'}             => $level
                                       {'error'}             => latest error message for the dle
                                       {'storage'}           => $storage_name  # when dump to tape.
                                       {'message'}           => amstatus message
                                                                  getting estimate
                                                                  partial estimate
                                                                  estimate done
                                                                  estimate failed
                                                                  wait for dumping
                                                                  dumping
                                                                  dumping to tape
                                                                  dump failed: $error
                                                                  will retry at level $retry_level: $error
                                                                  will retry: $error
                                                                  dump to tape failed: $error
                                                                  dump done
                                                                  dump to tape done
                                       {'holding_file'}      => holding disk file path
                                       {'size'}              => real size
                                       {'esize'}             => estimated size
                                       {'wsize'}             => working size (when dumping)
                                       {'dsize'}             => dumped size (when dumping done)
                                       {'dump_time'}         => time the dump started or finished
                                       {'chunk_time'}        => time the dump started or finished
                                       {'retry'}             => if dumper tell us to retry (from application)
                                       {'retry_level'}       => the level of the retry
                                       {'will_retry'}        => if that dump will be retried
                                       {'wait_holding_disk'} => 1 if dump to holding disk wait for more space
                                       {'failed_to_tape'}    #internal use
                                       {'taped'}             #internal use
                                       {'flush'}             #internal use
                                       {'writing_to_tape'}   #internal use
                                       {'wait_fo_writing'}   #internal use
 dles->{$host}->{$disk}->{$datestamp}->{'storage'}->{$storage_name}->{'status'}          => $status
                                                                                              $IDLE
                                                                                              $WAIT_FOR_FLUSHING
                                                                                              $WAIT_FOR_WRITING
                                                                                              $FLUSHING
                                                                                              $WRITING
                                                                                              $DUMPING_TO_TAPE
                                                                                              $DUMPING_TO_TAPE_DUMPER
                                                                                              $DUMP_TO_TAPE_FAILED
                                                                                              $WRITE_FAILED
                                                                                              $FLUSH_FAILED
                                                                                              $FLUSH_DONE
                                                                                              $WRITE_DONE
                                                                                              $DUMP_TO_TAPE_DONE
                                                                                              $CONFIG_ERROR
                                                                     {'message'}         => amstatus message
                                                                                              Idle
                                                                                              wait for flushing
                                                                                              wait for writing
                                                                                              flushing
                                                                                              writing
                                                                                              dumping to tape
                                                                                              dump to tape failed
                                                                                              write failed
                                                                                              flush failed
                                                                                              partially flushed
                                                                                              flushed
                                                                                              partially written
                                                                                              written
                                                                                              dump to tape done
                                                                                              $tape_config
                                                                                              waiting for a tape
                                                                                              searching for a tape
                                                                     {'size'}            => real size
                                                                     {'dsize'}           => taped size (when flush done)
                                                                     {'wsize'}           => working size (when flushing)
                                                                     {'partial'}         => partial flush
                                                                     {'taper_time'}      => time the flush started or finished
                                                                     {'error'}           => tape or config error
                                                                     {'flushing'}        #internal use
                                                                     {'wait_for_tape'}   => 1 if waiting for a tape
                                                                     {'search_for_tape'} => 1 if searching for a tape
                                                                     {'tape_error'}      => tape error message
                                                                     {'tape_config'}     => config error message
                                                                     {'will_retry'}      => if that dump_to_tape/flush/write/vault will be retried
 taper->{$taper}->{'storage'}   => $storage
 taper->{$taper}->{'tape_size'} => tape size for the storage
 taper->{$taper}->{'nb_tape'} => number of tape used
 taper->{$taper}->{'worker'}->{$worker}->{'status'}            => $status
                                         {'taper_status_file'} => filename of status file for the flush
                                         {'message'}           => amstatus message
                                         {'error'}             => error message
                                         {'host'}              => host actualy flushing
                                         {'disk'}              => disk actualy flushing
                                         {'datestamp'}         => datestamp actualy flushing
                                         {'wait_for_tape'}     => 1 if worker wait for a tape
                                         {'search_for_tape'}   => 1 if worker search for a tape
                                         {'no_tape'}           => index in {taper->{$taper}->{'stat'}[]} of actualy writing tape
 taper->{$taper}->{'stat'}[]->{'label'}   => label of the tape
                              {'nb_dle'}  => number of dle
                              {'nb_part'} => number of part
                              {'size'}    => real size
                              {'esize'}   => estimated size
                              {'percent'} =>
 storage->{$storage}->{'taper'} = $taper;
 qlen->{'tapeq'}->{'taper'}->{$taper} => number of dle in queue
 qlen->{'tapeq'}->{'roomq'} => number of dle in queue
 qlen->{'tapeq'}->{'runq'}  => number of dle in queue
 busy->{$process}->{'type'}    => 'dumper' or 'chunker' or 'taper'
                   {'time'}    =>
                   {'percent'} =>
                   {'storage'} => $storage # for type eq 'taper'
 busy_dumper =>
 stat->{$status}->{'real_size'}      =>
                  {'real_stat'}      =>
                  {'estimated_size'} =>
                  {'estimated_stat'} =>
                  {'write_size'}     =>
                  {'name'}           => To print to user
    where $status can be  disk
                          estimated
                          wait_for_dumping
                          dumping
                          dumping_to_tape
                          dump_failed
                          dump_to_tape_failed
                          dumped
                          flush
                          wait_to_flush
                          wait_for_writing
                          writing_to_tape
                          failed_to_tape
                          taped
 stat->{'taped'}->{'storage'}->{$storage}->{'real_size'}      =>
                                           {'real_stat'}      =>
                                           {'estimated_size'} =>
                                           {'estimated_stat'} =>
                                           {'write_size'}     =>
                                           {'nb'}             =>

 status
   $IDLE                         =  0;
   $ESTIMATING                   =  1;  # estimating the dle, got no estimate result yet
   $ESTIMATE_PARTIAL             =  2;  # estimating the dle, got the estimate result for at least one level
   $ESTIMATE_DONE                =  3;  # receive the estimate for all levels
   $ESTIMATE_FAILED              =  4;  # estimate for all levels failed
   $WAIT_FOR_DUMPING             =  5;  # wait for dumping
   $DUMPING_INIT                 =  6;  # dumping initialization phase
   $DUMPING                      =  7;  # dumping
   $DUMPING_DUMPER               =  8;  # dumping ending phase
   $DUMPING_TO_TAPE_INIT         =  9;  # dumping to tape initialisation phase
   $DUMPING_TO_TAPE              = 10;  # dumping to tape
   $DUMPING_TO_TAPE_DUMPER       = 11;  # dumping to tape ending phase
   $DUMP_FAILED                  = 12;  # dump failed
   $DUMP_TO_TAPE_FAILED          = 13;  # dump to tape failed
   $WAIT_FOR_WRITING             = 14;  # wait for writing
   $WRITING                      = 15;  # writing a dump from holding disk
   $WRITE_FAILED                 = 16;  # writing failed
   $WAIT_FOR_FLUSHING            = 17;  # wait for flushing
   $FLUSHING                     = 18;  # flushing
   $FLUSH_FAILED                 = 19;  # flush failed
   $DUMP_DONE                    = 20;  # dump done and succeeded
   $DUMP_TO_TAPE_DONE            = 21;  # dump to tape done and succeeded
   $WRITE_DONE                   = 22;  # write done and succeeded
   $FLUSH_DONE                   = 23;  # flush done and succeeded
   $VAULTING                     = 27;  # vaulting
   $VAULTING_DONE                = 28;  # vaulting done and succeded
   $VAULTING_FAILED              = 29;  # vaulting failed

 status only for worker
   $TAPE_ERROR                   = 50;  # failed because of tape error
   $CONFIG_ERROR                 = 51;  # failed because of config (runtapes, ...)

 dle status
  IDLE => ESTIMATING => ESTIMATE_FAILED
                     => ESTIMATE_PARTIAL => ESTIMATE_DONE => WAIT_FOR_DUMPING

  WAIT_FOR_DUMPING => DUMPING_INIT => DUMPING => DUMPING_DUMPER => DUMP_DONE
                                                                => DUMP_FAILED

  WAIT_FOR_DUMPING => DUMPING_TO_TAPE_INIT => DUMPING_TO_TAPE => DUMPING_TO_TAPE_DUMPER => DUMP_TO_TAPE_DONE
                                                                                        => DUMP_TO_TAPE_FAILED

 storage status
  dump to tape
   IDLE => DUMPING_TO_TAPE => DUMPING_TO_TAPE_DUMPER => DUMPING_TO_TAPE_DONE
                                                     => DUMP_TO_TAPE_FAILED
                                                     => CONFIG_ERROR
  flush
   IDLE => WAIT_FOR_FLUSHING => FLUSHING => FLUSH_DONE
                                         => FLUSH_FAILED
                                         => CONFIG_ERROR

  vault
   IDLE => WAIT_FOR_WRITING => WRITING => WRITE_DONE
                                       => WRITE_FAILED
                                       => CONFIG_ERROR

ABOUT THIS PAGE

This page was automatically generated Tue Mar 19 07:08:17 2019 from the Amanda source tree, and documents the most recent development version of Amanda. For documentation specific to the version of Amanda on your system, use the 'perldoc' command.


4.0.0alpha.svn.7719