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

   1 #!/usr/bin/perl -w
   2 use strict;
   3 my $bresto_enable = 1;
   4 die "bresto is not enabled" if (not $bresto_enable);
   5
   6 =head1 LICENSE
   7
   8    Bweb - A Bacula web interface
   9    Bacula® - The Network Backup Solution
  10
  11    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  12
  13    The main author of Bweb is Eric Bollengier.
  14    The main author of Bacula is Kern Sibbald, with contributions from
  15    many others, a complete list can be found in the file AUTHORS.
  16
  17    This program is Free Software; you can redistribute it and/or
  18    modify it under the terms of version two of the GNU General Public
  19    License as published by the Free Software Foundation plus additions
  20    that are listed in the file LICENSE.
  21
  22    This program is distributed in the hope that it will be useful, but
  23    WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25    General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  30    02110-1301, USA.
  31
  32    Bacula® is a registered trademark of Kern Sibbald.
  33    The licensor of Bacula is the Free Software Foundation Europe
  34    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zurich,
  35    Switzerland, email:ftf@fsfeurope.org.
  36
  37 =head1 VERSION
  38
  39     $Id$
  40
  41 =cut
  42
  43 use Bweb;
  44
  45 package Bvfs;
  46 use base qw/Bweb/;
  47
  48 sub get_root
  49 {
  50     my ($self) = @_;
  51     return $self->get_pathid('');
  52 }
  53
  54 # change the current directory
  55 sub ch_dir
  56 {
  57     my ($self, $pathid) = @_;
  58     $self->{cwdid} = $pathid;
  59 }
  60
  61 # do a cd ..
  62 sub up_dir
  63 {
  64     my ($self) = @_ ;
  65     my $query = "
  66   SELECT PPathId
  67     FROM brestore_pathhierarchy
  68    WHERE PathId IN ($self->{cwdid}) ";
  69
  70     my $all = $self->dbh_selectall_arrayref($query);
  71     return unless ($all);       # already at root
  72
  73     my $dir = join(',', map { $_->[0] } @$all);
  74     if ($dir) {
  75         $self->ch_dir($dir);
  76     }
  77 }
  78
  79 # return the current PWD
  80 sub pwd
  81 {
  82     my ($self) = @_;
  83     return $self->get_path($self->{cwdid});
  84 }
  85
  86 # get the Path from a PathId
  87 sub get_path
  88 {
  89     my ($self, $pathid) = @_;
  90     $self->debug("Call with pathid = $pathid");
  91     my $query = "SELECT Path FROM Path WHERE PathId = ?";
  92     my $sth = $self->dbh_prepare($query);
  93     $sth->execute($pathid);
  94     my $result = $sth->fetchrow_arrayref();
  95     $sth->finish();
  96     return $result->[0];
  97 }
  98
  99 # we are working with these jobids
 100 sub set_curjobids
 101 {
 102     my ($self, @jobids) = @_;
 103     $self->{curjobids} = join(',', @jobids);
 104 #    $self->update_brestore_table(@jobids);
 105 }
 106
 107 # get the PathId from a Path
 108 sub get_pathid
 109 {
 110     my ($self, $dir) = @_;
 111     my $query =
 112         "SELECT PathId FROM Path WHERE Path = ?";
 113     my $sth = $self->dbh_prepare($query);
 114     $sth->execute($dir);
 115     my $result = $sth->fetchrow_arrayref();
 116     $sth->finish();
 117
 118     return $result->[0];
 119 }
 120
 121 sub set_limits
 122 {
 123     my ($self, $offset, $limit) = @_;
 124     $self->{limit}  = $limit  || 100;
 125     $self->{offset} = $offset || 0;
 126 }
 127
 128 sub set_pattern
 129 {
 130     my ($self, $pattern) = @_;
 131     $self->{pattern} = $pattern;
 132 }
 133
 134 # fill brestore_xxx tables for speedup
 135 sub update_cache
 136 {
 137     my ($self) = @_;
 138
 139     $self->{dbh}->begin_work();
 140
 141     # getting all Jobs to "cache"
 142     my $query = "
 143   SELECT JobId from Job
 144    WHERE JobId NOT IN (SELECT JobId FROM brestore_knownjobid)
 145      AND Type IN ('B') AND JobStatus IN ('T', 'f', 'A')
 146    ORDER BY JobId";
 147     my $jobs = $self->dbh_selectall_arrayref($query);
 148
 149     $self->update_brestore_table(map { $_->[0] } @$jobs);
 150
 151     $self->{dbh}->commit();
 152     $self->{dbh}->begin_work(); # we can break here
 153
 154     print STDERR "Cleaning path visibility\n";
 155
 156     my $nb = $self->dbh_do("
 157   DELETE FROM brestore_pathvisibility
 158       WHERE NOT EXISTS
 159    (SELECT 1 FROM Job WHERE JobId=brestore_pathvisibility.JobId)");
 160
 161     print STDERR "$nb rows affected\n";
 162     print STDERR "Cleaning known jobid\n";
 163
 164     $nb = $self->dbh_do("
 165   DELETE FROM brestore_knownjobid
 166       WHERE NOT EXISTS
 167    (SELECT 1 FROM Job WHERE JobId=brestore_knownjobid.JobId)");
 168
 169     print STDERR "$nb rows affected\n";
 170
 171     $self->{dbh}->commit();
 172 }
 173
 174 sub update_brestore_table
 175 {
 176     my ($self, @jobs) = @_;
 177
 178     $self->debug(\@jobs);
 179
 180     foreach my $job (sort {$a <=> $b} @jobs)
 181     {
 182         my $query = "SELECT 1 FROM brestore_knownjobid WHERE JobId = $job";
 183         my $retour = $self->dbh_selectrow_arrayref($query);
 184         next if ($retour and ($retour->[0] == 1)); # We have allready done this one ...
 185
 186         print STDERR "Inserting path records for JobId $job\n";
 187         $query = "INSERT INTO brestore_pathvisibility (PathId, JobId)
 188                    (SELECT DISTINCT PathId, JobId FROM File WHERE JobId = $job)";
 189
 190         $self->dbh_do($query);
 191
 192         # Now we have to do the directory recursion stuff to determine missing visibility
 193         # We try to avoid recursion, to be as fast as possible
 194         # We also only work on not allready hierarchised directories...
 195
 196         print STDERR "Creating missing recursion paths for $job\n";
 197
 198         $query = "
 199 SELECT brestore_pathvisibility.PathId, Path FROM brestore_pathvisibility
 200   JOIN Path ON( brestore_pathvisibility.PathId = Path.PathId)
 201        LEFT JOIN brestore_pathhierarchy ON (brestore_pathvisibility.PathId = brestore_pathhierarchy.PathId)
 202  WHERE brestore_pathvisibility.JobId = $job
 203    AND brestore_pathhierarchy.PathId IS NULL
 204  ORDER BY Path";
 205
 206         my $sth = $self->dbh_prepare($query);
 207         $sth->execute();
 208         my $pathid; my $path;
 209         $sth->bind_columns(\$pathid,\$path);
 210
 211         while ($sth->fetch)
 212         {
 213             $self->build_path_hierarchy($path,$pathid);
 214         }
 215         $sth->finish();
 216
 217         # Great. We have calculated all dependancies. We can use them to add the missing pathids ...
 218         # This query gives all parent pathids for a given jobid that aren't stored.
 219         # It has to be called until no record is updated ...
 220         $query = "
 221 INSERT INTO brestore_pathvisibility (PathId, JobId) (
 222  SELECT a.PathId,$job
 223    FROM (
 224      SELECT DISTINCT h.PPathId AS PathId
 225        FROM brestore_pathhierarchy AS h
 226        JOIN  brestore_pathvisibility AS p ON (h.PathId=p.PathId)
 227       WHERE p.JobId=$job) AS a LEFT JOIN
 228        (SELECT PathId
 229           FROM brestore_pathvisibility
 230          WHERE JobId=$job) AS b ON (a.PathId = b.PathId)
 231   WHERE b.PathId IS NULL)";
 232
 233         my $rows_affected;
 234         while (($rows_affected = $self->dbh_do($query)) and ($rows_affected !~ /^0/))
 235         {
 236             print STDERR "Recursively adding $rows_affected records from $job\n";
 237         }
 238         # Job's done
 239         $query = "INSERT INTO brestore_knownjobid (JobId) VALUES ($job)";
 240         $self->dbh_do($query);
 241     }
 242 }
 243
 244 # compute the parent directory
 245 sub parent_dir
 246 {
 247     my ($path) = @_;
 248     # Root Unix case :
 249     if ($path eq '/')
 250     {
 251         return '';
 252     }
 253     # Root Windows case :
 254     if ($path =~ /^[a-z]+:\/$/i)
 255     {
 256         return '';
 257     }
 258     # Split
 259     my @tmp = split('/',$path);
 260     # We remove the last ...
 261     pop @tmp;
 262     my $tmp = join ('/',@tmp) . '/';
 263     return $tmp;
 264 }
 265
 266 sub build_path_hierarchy
 267 {
 268     my ($self, $path,$pathid)=@_;
 269     # Does the ppathid exist for this ? we use a memory cache...
 270     # In order to avoid the full loop, we consider that if a dir is allready in the
 271     # brestore_pathhierarchy table, then there is no need to calculate all the hierarchy
 272     while ($path ne '')
 273     {
 274         if (! $self->{cache_ppathid}->{$pathid})
 275         {
 276             my $query = "SELECT PPathId FROM brestore_pathhierarchy WHERE PathId = ?";
 277             my $sth2 = $self->{dbh}->prepare_cached($query);
 278             $sth2->execute($pathid);
 279             # Do we have a result ?
 280             if (my $refrow = $sth2->fetchrow_arrayref)
 281             {
 282                 $self->{cache_ppathid}->{$pathid}=$refrow->[0];
 283                 $sth2->finish();
 284                 # This dir was in the db ...
 285                 # It means we can leave, the tree has allready been built for
 286                 # this dir
 287                 return 1;
 288             } else {
 289                 $sth2->finish();
 290                 # We have to create the record ...
 291                 # What's the current p_path ?
 292                 my $ppath = parent_dir($path);
 293                 my $ppathid = $self->return_pathid_from_path($ppath);
 294                 $self->{cache_ppathid}->{$pathid}= $ppathid;
 295
 296                 $query = "INSERT INTO brestore_pathhierarchy (pathid, ppathid) VALUES (?,?)";
 297                 $sth2 = $self->{dbh}->prepare_cached($query);
 298                 $sth2->execute($pathid,$ppathid);
 299                 $sth2->finish();
 300                 $path = $ppath;
 301                 $pathid = $ppathid;
 302             }
 303         } else {
 304            # It's allready in the cache.
 305            # We can leave, no time to waste here, all the parent dirs have allready
 306            # been done
 307            return 1;
 308         }
 309     }
 310     return 1;
 311 }
 312
 313 sub return_pathid_from_path
 314 {
 315     my ($self, $path) = @_;
 316     my $query = "SELECT PathId FROM Path WHERE Path = ?";
 317
 318     #print STDERR $query,"\n" if $debug;
 319     my $sth = $self->{dbh}->prepare_cached($query);
 320     $sth->execute($path);
 321     my $result =$sth->fetchrow_arrayref();
 322     $sth->finish();
 323     if (defined $result)
 324     {
 325         return $result->[0];
 326
 327     } else {
 328         # A bit dirty : we insert into path, and we have to be sure
 329         # we aren't deleted by a purge. We still need to insert into path to get
 330         # the pathid, because of mysql
 331         $query = "INSERT INTO Path (Path) VALUES (?)";
 332         #print STDERR $query,"\n" if $debug;
 333         $sth = $self->{dbh}->prepare_cached($query);
 334         $sth->execute($path);
 335         $sth->finish();
 336
 337         $query = "SELECT PathId FROM Path WHERE Path = ?";
 338         #print STDERR $query,"\n" if $debug;
 339         $sth = $self->{dbh}->prepare_cached($query);
 340         $sth->execute($path);
 341         $result = $sth->fetchrow_arrayref();
 342         $sth->finish();
 343         return $result->[0];
 344     }
 345 }
 346
 347 # list all files in a directory, accross curjobids
 348 sub ls_files
 349 {
 350     my ($self) = @_;
 351
 352     return undef unless ($self->{curjobids});
 353
 354     my $inclause   = $self->{curjobids};
 355     my $inpath = $self->{cwdid};
 356     my $filter = '';
 357     if ($self->{pattern}) {
 358         $filter = " AND Filename.Name $self->{sql}->{MATCH} $self->{pattern} ";
 359     }
 360
 361     my $query =
 362 "SELECT File.FilenameId, listfiles.id, listfiles.Name, File.LStat, File.JobId
 363  FROM File, (
 364        SELECT Filename.Name, max(File.FileId) as id
 365          FROM File, Filename
 366         WHERE File.FilenameId = Filename.FilenameId
 367           AND Filename.Name != ''
 368           AND File.PathId = $inpath
 369           AND File.JobId IN ($inclause)
 370           $filter
 371         GROUP BY Filename.Name
 372         ORDER BY Filename.Name LIMIT $self->{limit} OFFSET $self->{offset}
 373      ) AS listfiles
 374 WHERE File.FileId = listfiles.id";
 375
 376 #    print STDERR $query;
 377     $self->debug($query);
 378     my $result = $self->dbh_selectall_arrayref($query);
 379     $self->debug($result);
 380
 381     return $result;
 382 }
 383
 384 sub ls_special_dirs
 385 {
 386     my ($self) = @_;
 387     return undef unless ($self->{curjobids});
 388
 389     my $pathid = $self->{cwdid};
 390     my $jobclause = $self->{curjobids};
 391     my $dir_filenameid = $self->get_dir_filenameid();
 392
 393     my $sq1 =
 394 "((SELECT PPathId AS PathId, '..' AS Path
 395     FROM  brestore_pathhierarchy
 396    WHERE  PathId = $pathid)
 397 UNION
 398  (SELECT $pathid AS PathId, '.' AS Path))";
 399
 400     my $sq2 = "
 401 SELECT tmp.PathId, tmp.Path, LStat, JobId
 402   FROM $sq1 AS tmp  LEFT JOIN ( -- get attributes if any
 403        SELECT File1.PathId, File1.JobId, File1.LStat FROM File AS File1
 404        WHERE File1.FilenameId = $dir_filenameid
 405        AND File1.JobId IN ($jobclause)) AS listfile1
 406   ON (tmp.PathId = listfile1.PathId)
 407   ORDER BY tmp.Path, JobId DESC
 408 ";
 409
 410     my $result = $self->dbh_selectall_arrayref($sq2);
 411
 412     my @return_list;
 413     my $prev_dir='';
 414     foreach my $refrow (@{$result})
 415     {
 416         my $dirid = $refrow->[0];
 417         my $dir = $refrow->[1];
 418         my $lstat = $refrow->[3];
 419         my $jobid = $refrow->[2] || 0;
 420         next if ($dirid eq $prev_dir);
 421         my @return_array = ($dirid,$dir,$lstat,$jobid);
 422         push @return_list,(\@return_array);
 423         $prev_dir = $dirid;
 424     }
 425
 426     return \@return_list;
 427 }
 428
 429 # Let's retrieve the list of the visible dirs in this dir ...
 430 # First, I need the empty filenameid to locate efficiently
 431 # the dirs in the file table
 432 sub get_dir_filenameid
 433 {
 434     my ($self) = @_;
 435     if ($self->{dir_filenameid}) {
 436         return $self->{dir_filenameid};
 437     }
 438     my $query = "SELECT FilenameId FROM Filename WHERE Name = ''";
 439     my $sth = $self->dbh_prepare($query);
 440     $sth->execute();
 441     my $result = $sth->fetchrow_arrayref();
 442     $sth->finish();
 443     return $self->{dir_filenameid} = $result->[0];
 444 }
 445
 446 # list all directories in a directory, accross curjobids
 447 # return ($dirid,$dir_basename,$lstat,$jobid)
 448 sub ls_dirs
 449 {
 450     my ($self) = @_;
 451
 452     return undef unless ($self->{curjobids});
 453
 454     my $pathid = $self->{cwdid};
 455     my $jobclause = $self->{curjobids};
 456     my $filter ='';
 457
 458     if ($self->{pattern}) {
 459         $filter = " AND Path2.Path $self->{sql}->{MATCH} $self->{pattern} ";
 460     }
 461
 462     # Let's retrieve the list of the visible dirs in this dir ...
 463     # First, I need the empty filenameid to locate efficiently
 464     # the dirs in the file table
 465     my $dir_filenameid = $self->get_dir_filenameid();
 466
 467     # Then we get all the dir entries from File ...
 468     my $query = "
 469 SELECT PathId, Path, JobId, LStat FROM (
 470
 471     SELECT Path1.PathId, Path1.Path, lower(Path1.Path),
 472            listfile1.JobId, listfile1.LStat
 473     FROM (
 474        SELECT DISTINCT brestore_pathhierarchy1.PathId
 475        FROM brestore_pathhierarchy AS brestore_pathhierarchy1
 476        JOIN Path AS Path2
 477            ON (brestore_pathhierarchy1.PathId = Path2.PathId)
 478        JOIN brestore_pathvisibility AS brestore_pathvisibility1
 479            ON (brestore_pathhierarchy1.PathId = brestore_pathvisibility1.PathId)
 480        WHERE brestore_pathhierarchy1.PPathId = $pathid
 481        AND brestore_pathvisibility1.jobid IN ($jobclause)
 482            $filter
 483      ) AS listpath1
 484    JOIN Path AS Path1 ON (listpath1.PathId = Path1.PathId)
 485
 486    LEFT JOIN ( -- get attributes if any
 487        SELECT File1.PathId, File1.JobId, File1.LStat FROM File AS File1
 488        WHERE File1.FilenameId = $dir_filenameid
 489        AND File1.JobId IN ($jobclause)) AS listfile1
 490        ON (listpath1.PathId = listfile1.PathId)
 491      ) AS A ORDER BY 2,3 DESC LIMIT $self->{limit} OFFSET $self->{offset}
 492 ";
 493 #    print STDERR $query;
 494     my $sth=$self->dbh_prepare($query);
 495     $sth->execute();
 496     my $result = $sth->fetchall_arrayref();
 497     my @return_list;
 498     my $prev_dir='';
 499     foreach my $refrow (@{$result})
 500     {
 501         my $dirid = $refrow->[0];
 502         my $dir = $refrow->[1];
 503         my $lstat = $refrow->[3];
 504         my $jobid = $refrow->[2] || 0;
 505         next if ($dirid eq $prev_dir);
 506         # We have to clean up this dirname ... we only want it's 'basename'
 507         my $return_value;
 508         if ($dir ne '/')
 509         {
 510             my @temp = split ('/',$dir);
 511             $return_value = pop @temp;
 512         }
 513         else
 514         {
 515             $return_value = '/';
 516         }
 517         my @return_array = ($dirid,$return_value,$lstat,$jobid);
 518         push @return_list,(\@return_array);
 519         $prev_dir = $dirid;
 520     }
 521     $self->debug(\@return_list);
 522     return \@return_list;
 523 }
 524
 525 # TODO : we want be able to restore files from a bad ended backup
 526 # we have JobStatus IN ('T', 'A', 'E') and we must
 527
 528 # Data acces subs from here. Interaction with SGBD and caching
 529
 530 # This sub retrieves the list of jobs corresponding to the jobs selected in the
 531 # GUI and stores them in @CurrentJobIds.
 532 # date must be quoted
 533 sub set_job_ids_for_date
 534 {
 535     my ($self, $client, $date)=@_;
 536
 537     if (!$client or !$date) {
 538         return ();
 539     }
 540     my $filter = $self->get_client_filter();
 541     # The algorithm : for a client, we get all the backups for each
 542     # fileset, in reverse order Then, for each fileset, we store the 'good'
 543     # incrementals and differentials until we have found a full so it goes
 544     # like this : store all incrementals until we have found a differential
 545     # or a full, then find the full
 546     my $query = "
 547 SELECT JobId, FileSet, Level, JobStatus
 548   FROM Job
 549        JOIN FileSet USING (FileSetId)
 550        JOIN Client USING (ClientId) $filter
 551  WHERE EndTime <= $date
 552    AND Client.Name = '$client'
 553    AND Type IN ('B')
 554    AND JobStatus IN ('T')
 555  ORDER BY FileSet, JobTDate DESC";
 556
 557     my @CurrentJobIds;
 558     my $result = $self->dbh_selectall_arrayref($query);
 559     my %progress;
 560     foreach my $refrow (@$result)
 561     {
 562         my $jobid = $refrow->[0];
 563         my $fileset = $refrow->[1];
 564         my $level = $refrow->[2];
 565
 566         defined $progress{$fileset} or $progress{$fileset}='U'; # U for unknown
 567
 568         next if $progress{$fileset} eq 'F'; # It's over for this fileset...
 569
 570         if ($level eq 'I')
 571         {
 572             next unless ($progress{$fileset} eq 'U' or $progress{$fileset} eq 'I');
 573             push @CurrentJobIds,($jobid);
 574         }
 575         elsif ($level eq 'D')
 576         {
 577             next if $progress{$fileset} eq 'D'; # We allready have a differential
 578             push @CurrentJobIds,($jobid);
 579         }
 580         elsif ($level eq 'F')
 581         {
 582             push @CurrentJobIds,($jobid);
 583         }
 584
 585         my $status = $refrow->[3] ;
 586         if ($status eq 'T') {              # good end of job
 587             $progress{$fileset} = $level;
 588         }
 589     }
 590
 591     return @CurrentJobIds;
 592 }
 593
 594 sub dbh_selectrow_arrayref
 595 {
 596     my ($self, $query) = @_;
 597     $self->debug($query, up => 1);
 598     return $self->{dbh}->selectrow_arrayref($query);
 599 }
 600
 601 # Returns list of versions of a file that could be restored
 602 # returns an array of
 603 # (jobid,fileindex,mtime,size,inchanger,md5,volname,fileid)
 604 # there will be only one jobid in the array of jobids...
 605 sub get_all_file_versions
 606 {
 607     my ($self,$pathid,$fileid,$client,$see_all,$see_copies)=@_;
 608
 609     defined $see_all or $see_all=0;
 610     my $backup_type=" AND Job.Type = 'B' ";
 611     if ($see_copies) {
 612         $backup_type=" AND Job.Type IN ('C', 'B') ";
 613     }
 614
 615     my @versions;
 616     my $query;
 617     $query =
 618 "SELECT File.JobId, File.FileId, File.LStat,
 619         File.Md5, Media.VolumeName, Media.InChanger
 620  FROM File, Job, Client, JobMedia, Media
 621  WHERE File.FilenameId = $fileid
 622    AND File.PathId=$pathid
 623    AND File.JobId = Job.JobId
 624    AND Job.ClientId = Client.ClientId
 625    AND Job.JobId = JobMedia.JobId
 626    AND File.FileIndex >= JobMedia.FirstIndex
 627    AND File.FileIndex <= JobMedia.LastIndex
 628    AND JobMedia.MediaId = Media.MediaId
 629    AND Client.Name = '$client'
 630    $backup_type
 631 ";
 632
 633     $self->debug($query);
 634     my $result = $self->dbh_selectall_arrayref($query);
 635
 636     foreach my $refrow (@$result)
 637     {
 638         my ($jobid, $fid, $lstat, $md5, $volname, $inchanger) = @$refrow;
 639         my @attribs = parse_lstat($lstat);
 640         my $mtime = array_attrib('st_mtime',\@attribs);
 641         my $size = array_attrib('st_size',\@attribs);
 642
 643         my @list = ($pathid,$fileid,$jobid,
 644                     $fid, $mtime, $size, $inchanger,
 645                     $md5, $volname);
 646         push @versions, (\@list);
 647     }
 648
 649     # We have the list of all versions of this file.
 650     # We'll sort it by mtime desc, size, md5, inchanger desc, FileId
 651     # the rest of the algorithm will be simpler
 652     # ('FILE:',filename,jobid,fileindex,mtime,size,inchanger,md5,volname)
 653     @versions = sort { $b->[4] <=> $a->[4]
 654                     || $a->[5] <=> $b->[5]
 655                     || $a->[7] cmp $a->[7]
 656                     || $b->[6] <=> $a->[6]} @versions;
 657
 658     my @good_versions;
 659     my %allready_seen_by_mtime;
 660     my %allready_seen_by_md5;
 661     # Now we should create a new array with only the interesting records
 662     foreach my $ref (@versions)
 663     {
 664         if ($ref->[7])
 665         {
 666             # The file has a md5. We compare his md5 to other known md5...
 667             # We take size into account. It may happen that 2 files
 668             # have the same md5sum and are different. size is a supplementary
 669             # criterion
 670
 671             # If we allready have a (better) version
 672             next if ( (not $see_all)
 673                       and $allready_seen_by_md5{$ref->[7] .'-'. $ref->[5]});
 674
 675             # we never met this one before...
 676             $allready_seen_by_md5{$ref->[7] .'-'. $ref->[5]}=1;
 677         }
 678         # Even if it has a md5, we should also work with mtimes
 679         # We allready have a (better) version
 680         next if ( (not $see_all)
 681                   and $allready_seen_by_mtime{$ref->[4] .'-'. $ref->[5]});
 682         $allready_seen_by_mtime{$ref->[4] .'-'. $ref->[5] . '-' . $ref->[7]}=1;
 683
 684         # We reached there. The file hasn't been seen.
 685         push @good_versions,($ref);
 686     }
 687
 688     # To be nice with the user, we re-sort good_versions by
 689     # inchanger desc, mtime desc
 690     @good_versions = sort { $b->[4] <=> $a->[4]
 691                          || $b->[2] <=> $a->[2]} @good_versions;
 692
 693     return \@good_versions;
 694 }
 695 {
 696     my %attrib_name_id = ( 'st_dev' => 0,'st_ino' => 1,'st_mode' => 2,
 697                           'st_nlink' => 3,'st_uid' => 4,'st_gid' => 5,
 698                           'st_rdev' => 6,'st_size' => 7,'st_blksize' => 8,
 699                           'st_blocks' => 9,'st_atime' => 10,'st_mtime' => 11,
 700                           'st_ctime' => 12,'LinkFI' => 13,'st_flags' => 14,
 701                           'data_stream' => 15);;
 702     sub array_attrib
 703     {
 704         my ($attrib,$ref_attrib)=@_;
 705         return $ref_attrib->[$attrib_name_id{$attrib}];
 706     }
 707
 708     sub file_attrib
 709     {   # $file = [filenameid,listfiles.id,listfiles.Name, File.LStat, File.JobId]
 710
 711         my ($file, $attrib)=@_;
 712
 713         if (defined $attrib_name_id{$attrib}) {
 714
 715             my @d = split(' ', $file->[3]) ; # TODO : cache this
 716
 717             return from_base64($d[$attrib_name_id{$attrib}]);
 718
 719         } elsif ($attrib eq 'jobid') {
 720
 721             return $file->[4];
 722
 723         } elsif ($attrib eq 'name') {
 724
 725             return $file->[2];
 726
 727         } else  {
 728             die "Attribute not known : $attrib.\n";
 729         }
 730     }
 731
 732     sub lstat_attrib
 733     {
 734         my ($lstat,$attrib)=@_;
 735         if ($lstat and defined $attrib_name_id{$attrib})
 736         {
 737             my @d = split(' ', $lstat) ; # TODO : cache this
 738             return from_base64($d[$attrib_name_id{$attrib}]);
 739         }
 740         return 0;
 741     }
 742 }
 743
 744 {
 745     # Base 64 functions, directly from recover.pl.
 746     # Thanks to
 747     # Karl Hakimian <hakimian@aha.com>
 748     # This section is also under GPL v2 or later.
 749     my @base64_digits;
 750     my @base64_map;
 751     my $is_init=0;
 752     sub init_base64
 753     {
 754         @base64_digits = (
 755         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
 756         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 757         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
 758         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
 759         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
 760                           );
 761         @base64_map = (0) x 128;
 762
 763         for (my $i=0; $i<64; $i++) {
 764             $base64_map[ord($base64_digits[$i])] = $i;
 765         }
 766         $is_init = 1;
 767     }
 768
 769     sub from_base64 {
 770         if(not $is_init)
 771         {
 772             init_base64();
 773         }
 774         my $where = shift;
 775         my $val = 0;
 776         my $i = 0;
 777         my $neg = 0;
 778
 779         if (substr($where, 0, 1) eq '-') {
 780             $neg = 1;
 781             $where = substr($where, 1);
 782         }
 783
 784         while ($where ne '') {
 785             $val *= 64;
 786             my $d = substr($where, 0, 1);
 787             $val += $base64_map[ord(substr($where, 0, 1))];
 788             $where = substr($where, 1);
 789         }
 790
 791         return $val;
 792     }
 793
 794     sub parse_lstat {
 795         my ($lstat)=@_;
 796         my @attribs = split(' ',$lstat);
 797         foreach my $element (@attribs)
 798         {
 799             $element = from_base64($element);
 800         }
 801         return @attribs;
 802     }
 803 }
 804
 805 # get jobids that the current user can view (ACL)
 806 sub get_jobids
 807 {
 808   my ($self, @jobid) = @_;
 809   my $filter = $self->get_client_filter();
 810   if ($filter) {
 811     my $jobids = $self->dbh_join(@jobid);
 812     my $q="
 813 SELECT JobId
 814   FROM Job JOIN Client USING (ClientId) $filter
 815  WHERE Jobid IN ($jobids)";
 816     my $res = $self->dbh_selectall_arrayref($q);
 817     @jobid = map { $_->[0] } @$res;
 818   }
 819   return @jobid;
 820 }
 821
 822 ################################################################
 823
 824
 825 package main;
 826 use strict;
 827 use POSIX qw/strftime/;
 828 use Bweb;
 829
 830 my $conf = new Bweb::Config(config_file => $Bweb::config_file);
 831 $conf->load();
 832
 833 my $bvfs = new Bvfs(info => $conf);
 834 $bvfs->connect_db();
 835
 836 my $action = CGI::param('action') || '';
 837
 838 my $args = $bvfs->get_form('pathid', 'filenameid', 'fileid', 'qdate',
 839                            'limit', 'offset', 'client', 'qpattern');
 840
 841 if ($action eq 'batch') {
 842     $bvfs->update_cache();
 843     exit 0;
 844 }
 845
 846 # All these functions are returning JSON compatible data
 847 # for javascript parsing
 848
 849 if ($action eq 'list_client') { # list all client [ ['c1'],['c2']..]
 850     print CGI::header('application/x-javascript');
 851
 852     my $filter = $bvfs->get_client_filter();
 853     my $q = "SELECT Name FROM Client $filter";
 854     my $ret = $bvfs->dbh_selectall_arrayref($q);
 855
 856     print "[";
 857     print join(',', map { "['$_->[0]']" } @$ret);
 858     print "]\n";
 859     exit 0;
 860
 861 } elsif ($action eq 'list_job') {
 862     # list jobs for a client [[jobid,endtime,'desc'],..]
 863
 864     print CGI::header('application/x-javascript');
 865
 866     my $filter = $bvfs->get_client_filter();
 867     my $query = "
 868  SELECT Job.JobId,Job.EndTime, FileSet.FileSet, Job.Level, Job.JobStatus
 869   FROM Job JOIN FileSet USING (FileSetId) JOIN Client USING (ClientId) $filter
 870  WHERE Client.Name = '$args->{client}'
 871    AND Job.Type = 'B'
 872    AND JobStatus IN ('f', 'T')
 873  ORDER BY EndTime desc";
 874     my $result = $bvfs->dbh_selectall_arrayref($query);
 875
 876     print "[";
 877
 878     print join(',', map {
 879       "[$_->[0], '$_->[1]', '$_->[1] $_->[2] $_->[3] ($_->[4]) $_->[0]']"
 880       } @$result);
 881
 882     print "]\n";
 883     exit 0;
 884 } elsif ($action eq 'list_storage') { # TODO: use .storage here
 885     print CGI::header('application/x-javascript');
 886
 887     my $q="SELECT Name FROM Storage";
 888     my $lst = $bvfs->dbh_selectall_arrayref($q);
 889     print "[";
 890     print join(',', map { "[ '$_->[0]' ]" } @$lst);
 891     print "]\n";
 892     exit 0;
 893 }
 894
 895 sub fill_table_for_restore
 896 {
 897     my (@jobid) = @_;
 898
 899     # in "force" mode, we need the FileId to compute media list
 900     my $FileId = CGI::param('force')?",FileId":"";
 901
 902     my $fileid = join(',', grep { /^\d+$/ } CGI::param('fileid'));
 903     # can get dirid=("10,11", 10, 11)
 904     my @dirid = grep { /^\d+$/ } map { split(/,/) } CGI::param('dirid') ;
 905     my $inclause = join(',', @jobid);
 906
 907     my @union;
 908
 909     if ($fileid) {
 910       push @union,
 911       "(SELECT JobId, FileIndex, FilenameId, PathId $FileId
 912           FROM File WHERE FileId IN ($fileid))";
 913     }
 914
 915     # using this is not good because the sql engine doesn't know
 916     # what LIKE will use. It will be better to get Path% in perl
 917     # but it doesn't work with accents... :(
 918     foreach my $dirid (@dirid) {
 919       push @union, "
 920   (SELECT File.JobId, File.FileIndex, File.FilenameId, File.PathId $FileId
 921     FROM Path JOIN File USING (PathId)
 922    WHERE Path.Path LIKE
 923         (SELECT ". $bvfs->dbh_strcat('Path',"'\%'") ." FROM Path
 924           WHERE PathId = $dirid
 925         )
 926      AND File.JobId IN ($inclause))";
 927     }
 928
 929     return unless scalar(@union);
 930
 931     my $u = join(" UNION ", @union);
 932
 933     $bvfs->dbh_do("CREATE TEMPORARY TABLE btemp AS $u");
 934     # TODO: remove FilenameId et PathId
 935
 936     # now we have to choose the file with the max(jobid)
 937     # for each file of btemp
 938     if ($bvfs->dbh_is_mysql()) {
 939        $bvfs->dbh_do("CREATE TABLE b2$$ AS (
 940 SELECT max(JobId) as JobId, FileIndex $FileId
 941   FROM btemp
 942  GROUP BY PathId, FilenameId
 943  HAVING FileIndex > 0
 944 )");
 945    } else { # postgresql have distinct with more than one criteria
 946         $bvfs->dbh_do("CREATE TABLE b2$$ AS (
 947 SELECT JobId, FileIndex $FileId
 948 FROM (
 949  SELECT DISTINCT ON (PathId, FilenameId) JobId, FileIndex $FileId
 950    FROM btemp
 951   ORDER BY PathId, FilenameId, JobId DESC
 952  ) AS T
 953  WHERE FileIndex > 0
 954 )");
 955     }
 956
 957     return "b2$$";
 958 }
 959
 960 sub get_media_list_with_dir
 961 {
 962     my ($table) = @_;
 963     my $q="
 964  SELECT DISTINCT VolumeName, Enabled, InChanger
 965    FROM $table,
 966     ( -- Get all media from this job
 967       SELECT MIN(FirstIndex) AS FirstIndex, MAX(LastIndex) AS LastIndex,
 968              VolumeName, Enabled, Inchanger
 969         FROM JobMedia JOIN Media USING (MediaId)
 970        WHERE JobId IN (SELECT DISTINCT JobId FROM $table)
 971        GROUP BY VolumeName,Enabled,InChanger
 972     ) AS allmedia
 973   WHERE $table.FileIndex >= allmedia.FirstIndex
 974     AND $table.FileIndex <= allmedia.LastIndex
 975 ";
 976     my $lst = $bvfs->dbh_selectall_arrayref($q);
 977     return $lst;
 978 }
 979
 980 sub get_media_list
 981 {
 982     my ($jobid, $fileid) = @_;
 983     my $q="
 984  SELECT DISTINCT VolumeName, Enabled, InChanger
 985    FROM File,
 986     ( -- Get all media from this job
 987       SELECT MIN(FirstIndex) AS FirstIndex, MAX(LastIndex) AS LastIndex,
 988              VolumeName, Enabled, Inchanger
 989         FROM JobMedia JOIN Media USING (MediaId)
 990        WHERE JobId IN ($jobid)
 991        GROUP BY VolumeName,Enabled,InChanger
 992     ) AS allmedia
 993   WHERE File.FileId IN ($fileid)
 994     AND File.FileIndex >= allmedia.FirstIndex
 995     AND File.FileIndex <= allmedia.LastIndex
 996 ";
 997     my $lst = $bvfs->dbh_selectall_arrayref($q);
 998     return $lst;
 999 }
1000
1001 # get jobid param and apply user filter
1002 my @jobid = $bvfs->get_jobids(grep { /^\d+(,\d+)*$/ } CGI::param('jobid'));
1003
1004 # get jobid from date arg
1005 if (!scalar(@jobid) and $args->{qdate} and $args->{client}) {
1006     @jobid = $bvfs->set_job_ids_for_date($args->{client}, $args->{qdate});
1007 }
1008
1009 $bvfs->set_curjobids(@jobid);
1010 $bvfs->set_limits($args->{offset}, $args->{limit});
1011
1012 if (!scalar(@jobid)) {
1013     exit 0;
1014 }
1015
1016 if (CGI::param('init')) { # used when choosing a job
1017     $bvfs->update_brestore_table(@jobid);
1018 }
1019
1020 my $pathid = CGI::param('node') || CGI::param('pathid') || '';
1021 my $path = CGI::param('path');
1022
1023 if ($pathid =~ /^(\d+)$/) {
1024     $pathid = $1;
1025 } elsif ($path) {
1026     $pathid = $bvfs->get_pathid($path);
1027 } else {
1028     $pathid = $bvfs->get_root();
1029 }
1030 $bvfs->ch_dir($pathid);
1031
1032 #print STDERR "pathid=$pathid\n";
1033
1034 # permit to use a regex filter
1035 if ($args->{qpattern}) {
1036     $bvfs->set_pattern($args->{qpattern});
1037 }
1038
1039 if ($action eq 'restore') {
1040
1041     # TODO: pouvoir choisir le replace et le jobname
1042     my $arg = $bvfs->get_form(qw/client storage regexwhere where/);
1043
1044     if (!$arg->{client}) {
1045         print "ERROR: missing client\n";
1046         exit 1;
1047     }
1048
1049     my $table = fill_table_for_restore(@jobid);
1050     if (!$table) {
1051         exit 1;
1052     }
1053
1054     my $bconsole = $bvfs->get_bconsole();
1055     # TODO: pouvoir choisir le replace et le jobname
1056     my $jobid = $bconsole->run(client    => $arg->{client},
1057                                storage   => $arg->{storage},
1058                                where     => $arg->{where},
1059                                regexwhere=> $arg->{regexwhere},
1060                                restore   => 1,
1061                                file      => "?$table");
1062
1063     $bvfs->dbh_do("DROP TABLE $table");
1064
1065     if (!$jobid) {
1066         print CGI::header('text/html');
1067         $bvfs->display_begin();
1068         $bvfs->error("Can't start your job:<br/>" . $bconsole->before());
1069         $bvfs->display_end();
1070         exit 0;
1071     }
1072     sleep(2);
1073     print CGI::redirect("bweb.pl?action=dsp_cur_job;jobid=$jobid") ;
1074     exit 0;
1075 }
1076
1077 sub escape_quote
1078 {
1079     my ($str) = @_;
1080     if (!$str) {
1081         return '';
1082     }
1083     $str =~ s/'/\\'/g;
1084     return $str;
1085 }
1086
1087 print CGI::header('application/x-javascript');
1088
1089
1090 if ($action eq 'list_files_dirs') {
1091 # fileid, filenameid, pathid, jobid, name, size, mtime
1092     my $jids = join(",", @jobid);
1093
1094     my $files = $bvfs->ls_special_dirs();
1095     # return ($dirid,$dir_basename,$lstat,$jobid)
1096     print "[\n";
1097     print join(',',
1098                map { my @p=Bvfs::parse_lstat($_->[3]);
1099                      '[' . join(',',
1100                                 0, # fileid
1101                                 0, # filenameid
1102                                 $_->[0], # pathid
1103                                 "'$jids'", # jobid
1104                                 "'" . escape_quote($_->[1]) . "'", # name
1105                                 "'" . $p[7] . "'",                 # size
1106                                 "'" . strftime('%Y-%m-%d %H:%m:%S', localtime($p[11])) .  "'") .
1107                     ']';
1108                } @$files);
1109
1110     print "," if (@$files);
1111
1112     $files = $bvfs->ls_dirs();
1113     # return ($dirid,$dir_basename,$lstat,$jobid)
1114     print join(',',
1115                map { my @p=Bvfs::parse_lstat($_->[3]);
1116                      '[' . join(',',
1117                                 0, # fileid
1118                                 0, # filenameid
1119                                 $_->[0], # pathid
1120                                 "'$jids'", # jobid
1121                                 "'" . escape_quote($_->[1]) . "'", # name
1122                                 "'" . $p[7] . "'",                 # size
1123                                 "'" . strftime('%Y-%m-%d %H:%m:%S', localtime($p[11])) .  "'") .
1124                     ']';
1125                } @$files);
1126
1127     print "," if (@$files);
1128
1129     $files = $bvfs->ls_files();
1130     print join(',',
1131                map { my @p=Bvfs::parse_lstat($_->[3]);
1132                      '[' . join(',',
1133                                 $_->[1],
1134                                 $_->[0],
1135                                 $pathid,
1136                                 $_->[4],
1137                                 "'" . escape_quote($_->[2]) . "'",
1138                                 "'" . $p[7] . "'",
1139                                 "'" . strftime('%Y-%m-%d %H:%m:%S', localtime($p[11])) .  "'") .
1140                     ']';
1141                } @$files);
1142     print "]\n";
1143
1144 } elsif ($action eq 'list_files') {
1145     print "[[0,0,0,0,'.',4096,'1970-01-01 00:00:00'],";
1146     my $files = $bvfs->ls_files();
1147 #       [ 1, 2, 3, "Bill",  10, '2007-01-01 00:00:00'],
1148 #   File.FilenameId, listfiles.id, listfiles.Name, File.LStat, File.JobId
1149
1150     print join(',',
1151                map { my @p=Bvfs::parse_lstat($_->[3]);
1152                      '[' . join(',',
1153                                 $_->[1],
1154                                 $_->[0],
1155                                 $pathid,
1156                                 $_->[4],
1157                                 "'" . escape_quote($_->[2]) . "'",
1158                                 "'" . $p[7] . "'",
1159                                 "'" . strftime('%Y-%m-%d %H:%m:%S', localtime($p[11])) .  "'") .
1160                     ']';
1161                } @$files);
1162     print "]\n";
1163
1164 } elsif ($action eq 'list_dirs') {
1165
1166     print "[";
1167     my $dirs = $bvfs->ls_dirs();
1168     # return ($dirid,$dir_basename,$lstat,$jobid)
1169
1170     print join(',',
1171                map { "{ 'jobid': '$bvfs->{curjobids}', 'id': '$_->[0]'," .
1172                         "'text': '" . escape_quote($_->[1]) . "', 'cls':'folder'}" }
1173                @$dirs);
1174     print "]\n";
1175
1176 } elsif ($action eq 'list_versions') {
1177
1178     my $vafv = CGI::param('vafv') || 'false'; # view all file versions
1179     $vafv = ($vafv eq 'false')?0:1;
1180
1181     my $vcopies = CGI::param('vcopies') || 'false'; # view copies file versions
1182     $vcopies = ($vcopies eq 'false')?0:1;
1183
1184     print "[";
1185     #   0       1       2        3   4       5      6           7      8
1186     #($pathid,$fileid,$jobid, $fid, $mtime, $size, $inchanger, $md5, $volname);
1187     my $files = $bvfs->get_all_file_versions($args->{pathid}, $args->{filenameid}, $args->{client}, $vafv, $vcopies);
1188     print join(',',
1189                map { "[ $_->[3], $_->[1], $_->[0], $_->[2], '$_->[8]', $_->[6], '$_->[7]', $_->[5],'" . strftime('%Y-%m-%d %H:%m:%S', localtime($_->[4])) . "']" }
1190                @$files);
1191     print "]\n";
1192
1193 # this action is used when the restore box appear, we can display
1194 # the media list that will be needed for restore
1195 } elsif ($action eq 'get_media') {
1196     my ($jobid, $fileid, $table);
1197     my $lst;
1198
1199     # in this mode, we compute the result to get all needed media
1200 #    print STDERR "force=", CGI::param('force'), "\n";
1201     if (CGI::param('force')) {
1202         $table = fill_table_for_restore(@jobid);
1203         if (!$table) {
1204             exit 1;
1205         }
1206         # mysql is very slow without this index...
1207         if ($bvfs->dbh_is_mysql()) {
1208             $bvfs->dbh_do("CREATE INDEX idx_$table ON $table (JobId)");
1209         }
1210         $lst = get_media_list_with_dir($table);
1211     } else {
1212         $jobid = join(',', @jobid);
1213         $fileid = join(',', grep { /^\d+(,\d+)*$/ } CGI::param('fileid'));
1214         $lst = get_media_list($jobid, $fileid);
1215     }
1216
1217     if ($lst) {
1218         print "[";
1219         print join(',', map { "['$_->[0]',$_->[1],$_->[2]]" } @$lst);
1220         print "]\n";
1221     }
1222
1223     if ($table) {
1224         $bvfs->dbh_do("DROP TABLE $table");
1225     }
1226
1227 }
1228
1229 __END__
1230
1231 CREATE VIEW files AS
1232  SELECT path || name AS name,pathid,filenameid,fileid,jobid
1233    FROM File JOIN FileName USING (FilenameId) JOIN Path USING (PathId);
1234
1235 SELECT 'drop table ' || tablename || ';'
1236     FROM pg_tables WHERE tablename ~ '^b[0-9]';