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

   1 #!/usr/bin/perl -w
   2
   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 John Walker.
  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 # list all directories in a directory, accross curjobids
 385 # return ($dirid,$dir_basename,$lstat,$jobid)
 386 sub ls_dirs
 387 {
 388     my ($self) = @_;
 389
 390     return undef unless ($self->{curjobids});
 391
 392     my $pathid = $self->{cwdid};
 393     my $jobclause = $self->{curjobids};
 394
 395     # Let's retrieve the list of the visible dirs in this dir ...
 396     # First, I need the empty filenameid to locate efficiently
 397     # the dirs in the file table
 398     my $query = "SELECT FilenameId FROM Filename WHERE Name = ''";
 399     my $sth = $self->dbh_prepare($query);
 400     $sth->execute();
 401     my $result = $sth->fetchrow_arrayref();
 402     $sth->finish();
 403     my $dir_filenameid = $result->[0];
 404
 405     # Then we get all the dir entries from File ...
 406     $query = "
 407 SELECT PathId, Path, JobId, Lstat FROM (
 408
 409     SELECT Path1.PathId, Path1.Path, lower(Path1.Path),
 410            listfile1.JobId, listfile1.Lstat
 411     FROM (
 412        SELECT DISTINCT brestore_pathhierarchy1.PathId
 413        FROM brestore_pathhierarchy AS brestore_pathhierarchy1
 414        JOIN Path AS Path2
 415            ON (brestore_pathhierarchy1.PathId = Path2.PathId)
 416        JOIN brestore_pathvisibility AS brestore_pathvisibility1
 417            ON (brestore_pathhierarchy1.PathId = brestore_pathvisibility1.PathId)
 418        WHERE brestore_pathhierarchy1.PPathId = $pathid
 419        AND brestore_pathvisibility1.jobid IN ($jobclause)) AS listpath1
 420    JOIN Path AS Path1 ON (listpath1.PathId = Path1.PathId)
 421    LEFT JOIN (
 422        SELECT File1.PathId, File1.JobId, File1.Lstat FROM File AS File1
 423        WHERE File1.FilenameId = $dir_filenameid
 424        AND File1.JobId IN ($jobclause)) AS listfile1
 425        ON (listpath1.PathId = listfile1.PathId)
 426      ) AS A ORDER BY 2,3 DESC LIMIT $self->{limit} OFFSET $self->{offset}
 427 ";
 428     $self->debug($query);
 429     print STDERR $query;
 430     $sth=$self->dbh_prepare($query);
 431     $sth->execute();
 432     $result = $sth->fetchall_arrayref();
 433     my @return_list;
 434     my $prev_dir='';
 435     foreach my $refrow (@{$result})
 436     {
 437         my $dirid = $refrow->[0];
 438         my $dir = $refrow->[1];
 439         my $lstat = $refrow->[3];
 440         my $jobid = $refrow->[2] || 0;
 441         next if ($dirid eq $prev_dir);
 442         # We have to clean up this dirname ... we only want it's 'basename'
 443         my $return_value;
 444         if ($dir ne '/')
 445         {
 446             my @temp = split ('/',$dir);
 447             $return_value = pop @temp;
 448         }
 449         else
 450         {
 451             $return_value = '/';
 452         }
 453         my @return_array = ($dirid,$return_value,$lstat,$jobid);
 454         push @return_list,(\@return_array);
 455         $prev_dir = $dirid;
 456     }
 457     $self->debug(\@return_list);
 458     return \@return_list;
 459 }
 460
 461 # TODO : we want be able to restore files from a bad ended backup
 462 # we have JobStatus IN ('T', 'A', 'E') and we must
 463
 464 # Data acces subs from here. Interaction with SGBD and caching
 465
 466 # This sub retrieves the list of jobs corresponding to the jobs selected in the
 467 # GUI and stores them in @CurrentJobIds.
 468 # date must be quoted
 469 sub set_job_ids_for_date
 470 {
 471     my ($self, $client, $date)=@_;
 472
 473     if (!$client or !$date) {
 474         return ();
 475     }
 476     my $filter = $self->get_client_filter();
 477     # The algorithm : for a client, we get all the backups for each
 478     # fileset, in reverse order Then, for each fileset, we store the 'good'
 479     # incrementals and differentials until we have found a full so it goes
 480     # like this : store all incrementals until we have found a differential
 481     # or a full, then find the full
 482     my $query = "
 483 SELECT JobId, FileSet, Level, JobStatus
 484   FROM Job
 485        JOIN FileSet USING (FileSetId)
 486        JOIN Client USING (ClientId) $filter
 487  WHERE EndTime <= $date
 488    AND Client.Name = '$client'
 489    AND Type IN ('B')
 490    AND JobStatus IN ('T')
 491  ORDER BY FileSet, JobTDate DESC";
 492
 493     my @CurrentJobIds;
 494     my $result = $self->dbh_selectall_arrayref($query);
 495     my %progress;
 496     foreach my $refrow (@$result)
 497     {
 498         my $jobid = $refrow->[0];
 499         my $fileset = $refrow->[1];
 500         my $level = $refrow->[2];
 501
 502         defined $progress{$fileset} or $progress{$fileset}='U'; # U for unknown
 503
 504         next if $progress{$fileset} eq 'F'; # It's over for this fileset...
 505
 506         if ($level eq 'I')
 507         {
 508             next unless ($progress{$fileset} eq 'U' or $progress{$fileset} eq 'I');
 509             push @CurrentJobIds,($jobid);
 510         }
 511         elsif ($level eq 'D')
 512         {
 513             next if $progress{$fileset} eq 'D'; # We allready have a differential
 514             push @CurrentJobIds,($jobid);
 515         }
 516         elsif ($level eq 'F')
 517         {
 518             push @CurrentJobIds,($jobid);
 519         }
 520
 521         my $status = $refrow->[3] ;
 522         if ($status eq 'T') {              # good end of job
 523             $progress{$fileset} = $level;
 524         }
 525     }
 526
 527     return @CurrentJobIds;
 528 }
 529
 530 sub dbh_selectrow_arrayref
 531 {
 532     my ($self, $query) = @_;
 533     $self->debug($query, up => 1);
 534     return $self->{dbh}->selectrow_arrayref($query);
 535 }
 536
 537 # Returns list of versions of a file that could be restored
 538 # returns an array of
 539 # (jobid,fileindex,mtime,size,inchanger,md5,volname,fileid)
 540 # there will be only one jobid in the array of jobids...
 541 sub get_all_file_versions
 542 {
 543     my ($self,$pathid,$fileid,$client,$see_all)=@_;
 544
 545     defined $see_all or $see_all=0;
 546
 547     my @versions;
 548     my $query;
 549     $query =
 550 "SELECT File.JobId, File.FileId, File.Lstat,
 551         File.Md5, Media.VolumeName, Media.InChanger
 552  FROM File, Job, Client, JobMedia, Media
 553  WHERE File.FilenameId = $fileid
 554    AND File.PathId=$pathid
 555    AND File.JobId = Job.JobId
 556    AND Job.ClientId = Client.ClientId
 557    AND Job.JobId = JobMedia.JobId
 558    AND File.FileIndex >= JobMedia.FirstIndex
 559    AND File.FileIndex <= JobMedia.LastIndex
 560    AND JobMedia.MediaId = Media.MediaId
 561    AND Client.Name = '$client'";
 562
 563     $self->debug($query);
 564     my $result = $self->dbh_selectall_arrayref($query);
 565
 566     foreach my $refrow (@$result)
 567     {
 568         my ($jobid, $fid, $lstat, $md5, $volname, $inchanger) = @$refrow;
 569         my @attribs = parse_lstat($lstat);
 570         my $mtime = array_attrib('st_mtime',\@attribs);
 571         my $size = array_attrib('st_size',\@attribs);
 572
 573         my @list = ($pathid,$fileid,$jobid,
 574                     $fid, $mtime, $size, $inchanger,
 575                     $md5, $volname);
 576         push @versions, (\@list);
 577     }
 578
 579     # We have the list of all versions of this file.
 580     # We'll sort it by mtime desc, size, md5, inchanger desc, FileId
 581     # the rest of the algorithm will be simpler
 582     # ('FILE:',filename,jobid,fileindex,mtime,size,inchanger,md5,volname)
 583     @versions = sort { $b->[4] <=> $a->[4]
 584                     || $a->[5] <=> $b->[5]
 585                     || $a->[7] cmp $a->[7]
 586                     || $b->[6] <=> $a->[6]} @versions;
 587
 588     my @good_versions;
 589     my %allready_seen_by_mtime;
 590     my %allready_seen_by_md5;
 591     # Now we should create a new array with only the interesting records
 592     foreach my $ref (@versions)
 593     {
 594         if ($ref->[7])
 595         {
 596             # The file has a md5. We compare his md5 to other known md5...
 597             # We take size into account. It may happen that 2 files
 598             # have the same md5sum and are different. size is a supplementary
 599             # criterion
 600
 601             # If we allready have a (better) version
 602             next if ( (not $see_all)
 603                       and $allready_seen_by_md5{$ref->[7] .'-'. $ref->[5]});
 604
 605             # we never met this one before...
 606             $allready_seen_by_md5{$ref->[7] .'-'. $ref->[5]}=1;
 607         }
 608         # Even if it has a md5, we should also work with mtimes
 609         # We allready have a (better) version
 610         next if ( (not $see_all)
 611                   and $allready_seen_by_mtime{$ref->[4] .'-'. $ref->[5]});
 612         $allready_seen_by_mtime{$ref->[4] .'-'. $ref->[5] . '-' . $ref->[7]}=1;
 613
 614         # We reached there. The file hasn't been seen.
 615         push @good_versions,($ref);
 616     }
 617
 618     # To be nice with the user, we re-sort good_versions by
 619     # inchanger desc, mtime desc
 620     @good_versions = sort { $b->[4] <=> $a->[4]
 621                          || $b->[2] <=> $a->[2]} @good_versions;
 622
 623     return \@good_versions;
 624 }
 625 {
 626     my %attrib_name_id = ( 'st_dev' => 0,'st_ino' => 1,'st_mode' => 2,
 627                           'st_nlink' => 3,'st_uid' => 4,'st_gid' => 5,
 628                           'st_rdev' => 6,'st_size' => 7,'st_blksize' => 8,
 629                           'st_blocks' => 9,'st_atime' => 10,'st_mtime' => 11,
 630                           'st_ctime' => 12,'LinkFI' => 13,'st_flags' => 14,
 631                           'data_stream' => 15);;
 632     sub array_attrib
 633     {
 634         my ($attrib,$ref_attrib)=@_;
 635         return $ref_attrib->[$attrib_name_id{$attrib}];
 636     }
 637
 638     sub file_attrib
 639     {   # $file = [filenameid,listfiles.id,listfiles.Name, File.LStat, File.JobId]
 640
 641         my ($file, $attrib)=@_;
 642
 643         if (defined $attrib_name_id{$attrib}) {
 644
 645             my @d = split(' ', $file->[3]) ; # TODO : cache this
 646
 647             return from_base64($d[$attrib_name_id{$attrib}]);
 648
 649         } elsif ($attrib eq 'jobid') {
 650
 651             return $file->[4];
 652
 653         } elsif ($attrib eq 'name') {
 654
 655             return $file->[2];
 656
 657         } else  {
 658             die "Attribute not known : $attrib.\n";
 659         }
 660     }
 661
 662     sub lstat_attrib
 663     {
 664         my ($lstat,$attrib)=@_;
 665         if ($lstat and defined $attrib_name_id{$attrib})
 666         {
 667             my @d = split(' ', $lstat) ; # TODO : cache this
 668             return from_base64($d[$attrib_name_id{$attrib}]);
 669         }
 670         return 0;
 671     }
 672 }
 673
 674 {
 675     # Base 64 functions, directly from recover.pl.
 676     # Thanks to
 677     # Karl Hakimian <hakimian@aha.com>
 678     # This section is also under GPL v2 or later.
 679     my @base64_digits;
 680     my @base64_map;
 681     my $is_init=0;
 682     sub init_base64
 683     {
 684         @base64_digits = (
 685         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
 686         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 687         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
 688         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
 689         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
 690                           );
 691         @base64_map = (0) x 128;
 692
 693         for (my $i=0; $i<64; $i++) {
 694             $base64_map[ord($base64_digits[$i])] = $i;
 695         }
 696         $is_init = 1;
 697     }
 698
 699     sub from_base64 {
 700         if(not $is_init)
 701         {
 702             init_base64();
 703         }
 704         my $where = shift;
 705         my $val = 0;
 706         my $i = 0;
 707         my $neg = 0;
 708
 709         if (substr($where, 0, 1) eq '-') {
 710             $neg = 1;
 711             $where = substr($where, 1);
 712         }
 713
 714         while ($where ne '') {
 715             $val *= 64;
 716             my $d = substr($where, 0, 1);
 717             $val += $base64_map[ord(substr($where, 0, 1))];
 718             $where = substr($where, 1);
 719         }
 720
 721         return $val;
 722     }
 723
 724     sub parse_lstat {
 725         my ($lstat)=@_;
 726         my @attribs = split(' ',$lstat);
 727         foreach my $element (@attribs)
 728         {
 729             $element = from_base64($element);
 730         }
 731         return @attribs;
 732     }
 733 }
 734
 735 # get jobids that the current user can view (ACL)
 736 sub get_jobids
 737 {
 738   my ($self, @jobid) = @_;
 739   my $filter = $self->get_client_filter();
 740   if ($filter) {
 741     my $jobids = $self->dbh_join(@jobid);
 742     my $q="
 743 SELECT JobId
 744   FROM Job JOIN Client USING (ClientId) $filter
 745  WHERE Jobid IN ($jobids)";
 746     my $res = $self->dbh_selectall_arrayref($q);
 747     @jobid = map { $_->[0] } @$res;
 748   }
 749   return @jobid;
 750 }
 751
 752 ################################################################
 753
 754
 755 package main;
 756 use strict;
 757 use POSIX qw/strftime/;
 758 use Bweb;
 759
 760 my $conf = new Bweb::Config(config_file => $Bweb::config_file);
 761 $conf->load();
 762
 763 my $bvfs = new Bvfs(info => $conf);
 764 $bvfs->connect_db();
 765
 766 my $action = CGI::param('action') || '';
 767
 768 my $args = $bvfs->get_form('pathid', 'filenameid', 'fileid', 'qdate',
 769                            'limit', 'offset', 'client', 'qpattern');
 770
 771 if ($action eq 'batch') {
 772     $bvfs->update_cache();
 773     exit 0;
 774 }
 775
 776 # All these functions are returning JSON compatible data
 777 # for javascript parsing
 778
 779 if ($action eq 'list_client') { # list all client [ ['c1'],['c2']..]
 780     print CGI::header('application/x-javascript');
 781
 782     my $filter = $bvfs->get_client_filter();
 783     my $q = "SELECT Name FROM Client $filter";
 784     my $ret = $bvfs->dbh_selectall_arrayref($q);
 785
 786     print "[";
 787     print join(',', map { "['$_->[0]']" } @$ret);
 788     print "]\n";
 789     exit 0;
 790
 791 } elsif ($action eq 'list_job') { # list jobs for a client [[jobid,endtime,'desc'],..]
 792     print CGI::header('application/x-javascript');
 793
 794     my $filter = $bvfs->get_client_filter();
 795     my $query = "
 796  SELECT Job.JobId,Job.EndTime, FileSet.FileSet, Job.Level, Job.JobStatus
 797   FROM Job JOIN FileSet USING (FileSetId) JOIN Client USING (ClientId) $filter
 798  WHERE Client.Name = '$args->{client}'
 799    AND Job.Type = 'B'
 800    AND JobStatus IN ('f', 'T')
 801  ORDER BY EndTime desc";
 802     my $result = $bvfs->dbh_selectall_arrayref($query);
 803
 804     print "[";
 805
 806     print join(',', map {
 807       "[$_->[0], '$_->[1]', '$_->[1] $_->[2] $_->[3] ($_->[4]) $_->[0]']"
 808       } @$result);
 809
 810     print "]\n";
 811     exit 0;
 812 } elsif ($action eq 'list_storage') { # TODO: use .storage here
 813     print CGI::header('application/x-javascript');
 814
 815     my $q="SELECT Name FROM Storage";
 816     my $lst = $bvfs->dbh_selectall_arrayref($q);
 817     print "[";
 818     print join(',', map { "[ '$_->[0]' ]" } @$lst);
 819     print "]\n";
 820     exit 0;
 821 }
 822
 823 # get jobid param and apply user filter
 824 my @jobid = $bvfs->get_jobids(grep { /^\d+(,\d+)*$/ } CGI::param('jobid'));
 825 # get jobid from date arg
 826 if (!scalar(@jobid) and $args->{qdate} and $args->{client}) {
 827     @jobid = $bvfs->set_job_ids_for_date($args->{client}, $args->{qdate});
 828 }
 829 $bvfs->set_curjobids(@jobid);
 830 print STDERR "limit=$args->{limit}:$args->{offset} date=$args->{qdate} currentjobids = ", join(",", @jobid), "\n";
 831 $bvfs->set_limits($args->{offset}, $args->{limit});
 832
 833 if (!scalar(@jobid)) {
 834     exit 0;
 835 }
 836
 837 if (CGI::param('init')) { # used when choosing a job
 838     $bvfs->update_brestore_table(@jobid);
 839 }
 840
 841 my $pathid = CGI::param('node') || '';
 842 my $path = CGI::param('path');
 843
 844 if ($pathid =~ /^(\d+)$/) {
 845     $pathid = $1;
 846 } elsif ($path) {
 847     $pathid = $bvfs->get_pathid($path);
 848 } else {
 849     $pathid = $bvfs->get_root();
 850 }
 851 $bvfs->ch_dir($pathid);
 852
 853 # permit to use a regex filter
 854 if ($args->{qpattern}) {
 855     $bvfs->set_pattern($args->{qpattern});
 856 }
 857
 858 if ($action eq 'restore') {
 859
 860     # TODO: pouvoir choisir le replace et le jobname
 861     my $arg = $bvfs->get_form(qw/client storage regexwhere where/);
 862
 863     if (!$arg->{client}) {
 864         print "ERROR: missing client\n";
 865         exit 1;
 866     }
 867
 868     my $fileid = join(',', grep { /^\d+$/ } CGI::param('fileid'));
 869     my @dirid = grep { /^\d+$/ } CGI::param('dirid');
 870     my $inclause = join(',', @jobid);
 871
 872     my @union;
 873
 874     if ($fileid) {
 875       push @union,
 876       "(SELECT JobId, FileIndex, FilenameId, PathId FROM File WHERE FileId IN ($fileid))";
 877     }
 878
 879     # using this is not good because the sql engine doesn't know
 880     # what LIKE will use. It will be better to get Path% in perl
 881     # but it doesn't work with accents... :(
 882     foreach my $dirid (@dirid) {
 883       push @union, "
 884   (SELECT File.JobId, File.FileIndex, File.FilenameId, File.PathId
 885     FROM Path JOIN File USING (PathId)
 886    WHERE Path.Path LIKE
 887         (SELECT ". $bvfs->dbh_strcat('Path',"'\%'") ." FROM Path
 888           WHERE PathId = $dirid
 889         )
 890      AND File.JobId IN ($inclause))";
 891     }
 892
 893     return unless scalar(@union);
 894
 895     my $u = join(" UNION ", @union);
 896
 897     $bvfs->dbh_do("CREATE TEMPORARY TABLE btemp AS $u");
 898     # TODO: remove FilenameId et PathId
 899
 900     # now we have to choose the file with the max(jobid)
 901     # for each file of btemp
 902     if ($bvfs->dbh_is_mysql()) {
 903        $bvfs->dbh_do("CREATE TEMPORARY TABLE btemp2 AS (
 904 SELECT max(JobId) as JobId, PathId, FilenameId
 905   FROM btemp
 906  GROUP BY PathId, FilenameId
 907  HAVING FileIndex > 0
 908 )");
 909        $bvfs->dbh_do("CREATE TABLE b2$$ AS (
 910 SELECT btemp.JobId, btemp.FileIndex, btemp.FilenameId, btemp.PathId
 911   FROM btemp, btemp2
 912   WHERE btemp2.JobId = btemp.JobId
 913     AND btemp2.PathId= btemp.PathId
 914     AND btemp2.FilenameId = btemp.FilenameId
 915 )");
 916    } else { # postgresql have distinct with more than one criteria...
 917         $bvfs->dbh_do("CREATE TABLE b2$$ AS (
 918 SELECT JobId, FileIndex
 919 FROM (
 920  SELECT DISTINCT ON (PathId, FilenameId) JobId, FileIndex
 921    FROM btemp
 922   ORDER BY PathId, FilenameId, JobId DESC
 923  ) AS T
 924  WHERE FileIndex > 0
 925 )");
 926     }
 927
 928     my $bconsole = $bvfs->get_bconsole();
 929     # TODO: pouvoir choisir le replace et le jobname
 930     my $jobid = $bconsole->run(client    => $arg->{client},
 931                                storage   => $arg->{storage},
 932                                where     => $arg->{where},
 933                                regexwhere=> $arg->{regexwhere},
 934                                restore   => 1,
 935                                file      => "?b2$$");
 936
 937     $bvfs->dbh_do("DROP TABLE b2$$");
 938
 939     if (!$jobid) {
 940         print CGI::header('text/html');
 941         $bvfs->display_begin();
 942         $bvfs->error("Can't start your job:<br/>" . $bconsole->before());
 943         $bvfs->display_end();
 944         exit 0;
 945     }
 946     sleep(2);
 947     print CGI::redirect("bweb.pl?action=dsp_cur_job;jobid=$jobid") ;
 948     exit 0;
 949 }
 950
 951 sub escape_quote
 952 {
 953     my ($str) = @_;
 954     $str =~ s/'/\\'/g;
 955     return $str;
 956 }
 957
 958 print CGI::header('application/x-javascript');
 959
 960 if ($action eq 'list_files') {
 961     print "[[0,0,0,0,'.',4096,'1970-01-01 00:00:00'],";
 962     my $files = $bvfs->ls_files();
 963 #       [ 1, 2, 3, "Bill",  10, '2007-01-01 00:00:00'],
 964 #   File.FilenameId, listfiles.id, listfiles.Name, File.LStat, File.JobId
 965
 966     print join(',',
 967                map { my @p=Bvfs::parse_lstat($_->[3]);
 968                      '[' . join(',',
 969                                 $_->[1],
 970                                 $_->[0],
 971                                 $pathid,
 972                                 $_->[4],
 973                                 "'" . escape_quote($_->[2]) . "'",
 974                                 "'" . $p[7] . "'",
 975                                 "'" . strftime('%Y-%m-%d %H:%m:%S', localtime($p[11])) .  "'") .
 976                     ']';
 977                } @$files);
 978     print "]\n";
 979
 980 } elsif ($action eq 'list_dirs') {
 981
 982     print "[";
 983     my $dirs = $bvfs->ls_dirs();
 984     # return ($dirid,$dir_basename,$lstat,$jobid)
 985
 986     print join(',',
 987                map { "{ 'jobid': '$bvfs->{curjobids}', 'id': '$_->[0]'," .
 988                         "'text': '" . escape_quote($_->[1]) . "', 'cls':'folder'}" }
 989                @$dirs);
 990     print "]\n";
 991
 992 } elsif ($action eq 'list_versions') {
 993
 994     my $vafv = CGI::param('vafv') || 'false'; # view all file versions
 995     $vafv = ($vafv eq 'false')?0:1;
 996
 997     print "[";
 998     #   0       1       2        3   4       5      6           7      8
 999     #($pathid,$fileid,$jobid, $fid, $mtime, $size, $inchanger, $md5, $volname);
1000     my $files = $bvfs->get_all_file_versions($args->{pathid}, $args->{filenameid}, $args->{client}, $vafv);
1001     print join(',',
1002                map { "[ $_->[3], $_->[1], $_->[0], $_->[2], '$_->[8]', $_->[6], '$_->[7]', $_->[5],'" . strftime('%Y-%m-%d %H:%m:%S', localtime($_->[4])) . "']" }
1003                @$files);
1004     print "]\n";
1005
1006 } elsif ($action eq 'get_media') {
1007
1008     my $jobid = join(',', @jobid);
1009     my $fileid = join(',', grep { /^\d+(,\d+)*$/ } CGI::param('fileid'));
1010
1011     my $q="
1012  SELECT DISTINCT VolumeName, Enabled, InChanger
1013    FROM File,
1014     ( -- Get all media from this job
1015       SELECT MIN(FirstIndex) AS FirstIndex, MAX(LastIndex) AS LastIndex,
1016              VolumeName, Enabled, Inchanger
1017         FROM JobMedia JOIN Media USING (MediaId)
1018        WHERE JobId IN ($jobid)
1019        GROUP BY VolumeName,Enabled,InChanger
1020     ) AS allmedia
1021   WHERE File.FileId IN ($fileid)
1022     AND File.FileIndex >= allmedia.FirstIndex
1023     AND File.FileIndex <= allmedia.LastIndex
1024 ";
1025     my $lst = $bvfs->dbh_selectall_arrayref($q);
1026     print "[";
1027     print join(',', map { "['$_->[0]',$_->[1],$_->[2]]" } @$lst);
1028     print "]\n";
1029
1030 }
1031
1032 __END__
1033
1034 CREATE VIEW files AS
1035  SELECT path || name AS name,pathid,filenameid,fileid,jobid
1036    FROM File JOIN FileName USING (FilenameId) JOIN Path USING (PathId);
1037
1038 SELECT 'drop table ' || tablename || ';'
1039     FROM pg_tables WHERE tablename ~ '^b[0-9]';