git.sur5r.net Git - bacula/bacula/blob - gui/bweb/cgi/btime.pl

   1 #!/usr/bin/perl -w
   2
   3 =head1 LICENSE
   4
   5    Bweb - A Bacula web interface
   6    Bacula® - The Network Backup Solution
   7
   8    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
   9
  10    The main author of Bweb is Eric Bollengier.
  11    The main author of Bacula is Kern Sibbald, with contributions from
  12    many others, a complete list can be found in the file AUTHORS.
  13
  14    This program is Free Software; you can redistribute it and/or
  15    modify it under the terms of version two of the GNU General Public
  16    License as published by the Free Software Foundation plus additions
  17    that are listed in the file LICENSE.
  18
  19    This program is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  27    02110-1301, USA.
  28
  29    Bacula® is a registered trademark of John Walker.
  30    The licensor of Bacula is the Free Software Foundation Europe
  31    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zurich,
  32    Switzerland, email:ftf@fsfeurope.org.
  33
  34 =cut
  35
  36 use strict;
  37 use GTime;
  38 use Getopt::Long ;
  39 use Bweb;
  40 use Time::ParseDate qw/parsedate/;
  41 use POSIX qw/strftime/;
  42 use CGI;
  43
  44 my $conf = new Bweb::Config(config_file => $Bweb::config_file);
  45 $conf->load();
  46
  47 my $bweb = new Bweb(info => $conf);
  48
  49 print CGI::header('text/html');
  50 $bweb->display_begin();
  51 $bweb->can_do('r_view_stat');
  52
  53 my $arg = $bweb->get_form(qw/qnocache qiso_begin qiso_end qusage qpools
  54                              qpoolusage qnojob jclient_groups
  55                              db_client_groups qclient_groups/);
  56 my ($filter1, undef) = $bweb->get_param('pool');
  57
  58 if (!$arg->{qiso_begin}) {
  59    $arg->{qiso_begin} = strftime('\'%F %H:%M:00\'', localtime(time - 60*60*12));
  60    $arg->{qiso_end} = strftime('\'%F %H:%M:00\'', localtime(time));
  61 }
  62 use Digest::MD5 qw(md5_hex);
  63
  64 my $md5_rep = md5_hex("$arg->{qiso_begin}:$arg->{qiso_end}:$arg->{qusage}:" .
  65                       "$arg->{jclient_groups}:$arg->{qpoolusage};$arg->{qnojob}") ;
  66
  67 if (   !$arg->{qnocache}
  68     && $arg->{qiso_begin}
  69     && -f "$conf->{fv_write_path}/$md5_rep.png")
  70 {
  71     $arg->{result} = "/bweb/fv/$md5_rep.png";
  72     $bweb->display($arg, 'btime.tpl');
  73
  74     $bweb->display_end();
  75     exit 0;
  76 }
  77
  78 my $top = new GTime(
  79                     debug => $conf->{debug},
  80                     xmarge => 200,
  81                     type => {
  82                         spool =>  1,
  83                         despool =>  2,
  84                         commit => 4,
  85                         waiting => 3,
  86                         init => 5,
  87                     }) ;
  88 my $sec = $bweb->{sql}->{STARTTIME_SEC};
  89 $sec =~ s/Job.StartTime/Log.Time/;
  90 my $reg = $bweb->{sql}->{MATCH};
  91
  92
  93 my %regs = (
  94             end_job => ': Bacula',
  95             start_job => ': Start Backup|: D.marrage du ',
  96             data_despool_time => ': Despooling elapsed time|: Temps du tran',
  97             attr_despool_time => ': Sending spooled attrs|: Transfert des attributs',
  98             get_drive => ': Using Device',
  99             start_spool => ': Spooling',
 100             end_spool => ': User specified spool|: Taille du spool',
 101             end_spool2 => ': Committing spooled data to|: Transfert des donn',
 102     );
 103
 104 my %regs_en = (
 105             end_job => ': Bacula',
 106             start_job => ': Start Backup',
 107             data_despool_time => ': Despooling elapsed time',
 108             attr_despool_time => ': Sending spooled attrs',
 109             get_drive => ': Using Device',
 110             start_spool => ': Spooling',
 111             end_spool => ': User specified spool',
 112             end_spool2 => ': Committing spooled data to',
 113             );
 114
 115
 116 my %regs_fr = (
 117             end_job => ': Bacula',
 118             start_job => ': D.marrage du ',
 119             data_despool_time => ': Temps du tran',
 120             attr_despool_time => ': Transfert des attributs',
 121             get_drive => ': Using Device',
 122             start_spool => ': Spooling',
 123             end_spool => ': Taille du spool',
 124             end_spool2 => ': Transfert des donn',
 125             );
 126
 127 my $filter = join(" OR ",
 128                   map { "Log.LogText $bweb->{sql}->{MATCH} '$_'" } values %regs);
 129
 130 my $query = "
 131 SELECT " . $bweb->dbh_strcat('Job.Name', "'_'", 'Job.Level') . ",
 132        $sec,
 133        substring(Log.LogText from 8 for 70),
 134        Job.JobId,
 135        Pool.Name
 136
 137 FROM  Log INNER JOIN Job USING (JobId) JOIN Pool USING (PoolId)
 138 " . ($arg->{jclient_groups}?
 139 "     JOIN Client USING (ClientId)
 140       JOIN client_group_member ON (Client.ClientId = client_group_member.clientid)
 141       JOIN client_group USING (client_group_id)
 142       WHERE client_group_name IN ($arg->{jclient_groups})
 143         AND
 144 ":'WHERE') .
 145 "
 146       Job.StartTime > $arg->{qiso_begin}
 147   AND Job.StartTime < $arg->{qiso_end}
 148   AND ( $filter )
 149   AND Job.Type = 'B'
 150   $filter1
 151  ORDER BY Job.JobId,Log.LogId,Log.Time  ";
 152
 153
 154 $bweb->debug($query);
 155 my $all = $bweb->dbh_selectall_arrayref($query);
 156
 157 my $lastid = 0;
 158 my $lastspool = 0;
 159 my $last_name;
 160 my $data = [];
 161 my $write = {};
 162 my $pool = {};
 163 my $drive = "";
 164 my $end;
 165 my $begin;
 166 foreach my $elt (@$all)
 167 {
 168     if ($lastid && $lastid ne $elt->[3]) {
 169         if (!$arg->{qnojob}) {
 170             $top->add_job(label => $last_name,
 171                           data => $data);
 172         }
 173         $data = [];
 174         $lastspool=0;
 175     }
 176
 177     if ($elt->[2] =~ /$regs{end_job}/) {
 178         push @$data, {
 179             type  => "commit",
 180             begin => $begin,
 181             end   => $elt->[1],
 182         };
 183
 184 #    } elsif ($elt->[2] =~ /$regs{attr_despool_time}/) {
 185 #
 186 #       push @$data, {
 187 #           l => $elt->[2],
 188 #           type  => "waiting",
 189 #           begin => $begin,
 190 #           end   => $elt->[1],
 191 #       };
 192 #
 193     } elsif ($elt->[2] =~ /(?:$regs{get_drive}) "([\w\d]+)"/) {
 194         $drive = $1;
 195
 196     } elsif ($elt->[2] =~ /(?:$regs{data_despool_time}).*? = (\d+):(\d+):(\d+)/) {
 197         # on connait le temps de despool
 198         my $t = $1*60*60+ $2*60 + $3;
 199
 200         if ($t > 10) {          # en dessous de 10s on affiche pas
 201             push @$data, {      # temps d'attente du drive
 202 #               l => $elt->[2],
 203                 type  => "waiting",
 204                 begin => $begin,
 205                 end   => parsedate($elt->[1]) - $t,
 206             };
 207
 208             push @$data, {
 209 #               l => $elt->[2],
 210                 type  => "despool",
 211                 begin => parsedate($elt->[1]) - $t,
 212                 end   => $elt->[1],
 213             };
 214
 215             push @{$write->{$drive}}, { # display only write time
 216                 type  => "despool",
 217                 begin => parsedate($elt->[1]) - $t,
 218                 end   => $elt->[1],
 219             };
 220
 221             push @{$pool->{"$drive: $elt->[4]"}}, {
 222                 type  => "despool",
 223                 begin => parsedate($elt->[1]) - $t,
 224                 end   => $elt->[1],
 225             };
 226         } else {
 227             push @$data, {
 228 #               t => $t,
 229 #               l => $elt->[2],
 230                 type  => "waiting",
 231                 begin => $begin,
 232                 end   => $elt->[1],
 233             };
 234         }
 235
 236     } elsif ($elt->[2] =~ /$regs{start_spool}/) {
 237
 238         if (!$lastspool) {
 239             push @$data, {
 240                 type  => "init",
 241                 begin => $begin,
 242                 end   => $elt->[1],
 243             };
 244         }
 245
 246         $lastspool = 1;
 247
 248     } elsif ($elt->[2] =~ /($regs{end_spool}|$regs{end_spool2})/) {
 249         push @$data, {
 250 #           l => $elt->[2],
 251             type  => "spool",
 252             begin => $begin,
 253             end   => $elt->[1],
 254         };
 255
 256     } elsif ($elt->[2] =~ /$regs{start_job}/) {
 257         1;
 258     } else {
 259         next;
 260     }
 261
 262     $end = $begin;
 263     $begin = $elt->[1];
 264     $last_name = $elt->[0];
 265     $lastid = $elt->[3];
 266 }
 267
 268 if (!$arg->{qnojob} && $last_name) {
 269     $top->add_job(label => $last_name,
 270                   data => $data);
 271 }
 272 if ($arg->{qpoolusage}) {
 273     foreach my $d (sort keys %$pool) {
 274         $top->add_job(label => $d,
 275                       data => $pool->{$d});
 276     }
 277 }
 278
 279 if ($arg->{qusage}) {
 280     foreach my $d (sort keys %$write) {
 281         $top->add_job(label => "drive $d",
 282                       data => $write->{$d});
 283     }
 284 }
 285
 286 #print STDERR Data::Dumper::Dumper($top);
 287 $top->finalize();
 288
 289 open(FP, ">$conf->{fv_write_path}/$md5_rep.png");
 290 binmode FP;
 291 # Convert the image to PNG and print it on standard output
 292 print FP $GTime::gd->png;
 293 close(FP);
 294
 295 $arg->{result} = "/bweb/fv/$md5_rep.png";
 296 $bweb->display( $arg, 'btime.tpl');
 297 $bweb->display_end();