BackupPC/CGI/BurnMedia.pm

package BackupPC::CGI::BurnMedia;

use strict;
use BackupPC::CGI::Lib qw(:all);
use BackupPC::SearchLib;
use Data::Dumper;
use vars qw($Cgi %In $MyURL $User %Conf $TopDir $BinDir $bpc);

my $dsn = $Conf{SearchDSN};
my $db_user = $Conf{SearchUser} || '';

sub action() {
        my $cont = "";
        my $title;
        my $subtitle;
        my @files;

        my $dbh = DBI->connect($dsn, $db_user, "", { RaiseError => 1, AutoCommit => 0 } );

        BackupPC::CGI::Lib::NewRequest();
#       $cont = Dumper(%In);
        if (!defined($In{submitBurner})) {
                $title = eval(q{ ${h1($Lang->{Burn_media})}});
                $cont = Dumper(%In);
                $subtitle = eval(q{ ${h2($Lang->{Burn_media_select})}});
                $cont = <<EOF;

        $title
        $subtitle
        
EOF
              
                $cont .= "Backups that have not been archived:<br>";
                $cont .= BackupPC::SearchLib::displayBackupsGrid( \%In );
            
        } else {

                my @selected_backup_ids;

                my $total_size = 0;
                my $selected = 0;

                my $parts = 1;
                foreach my $key(keys(%In)) {
                        if ($key =~ m/^fcb([0-9]+)_([0-9]+)_([0-9]+)$/gi) {

                                my ($host_id, $backup_num, $backup_id) = ($1,$2,$3);
                                push @selected_backup_ids, $backup_id;
                                my $currSize = BackupPC::SearchLib::getGzipSizeFromBackupID($backup_id);
                                my $sth_size = $dbh->prepare(q{select inc_size from backups where id = ?});
                                $sth_size -> execute( $backup_id );
                                my $db_size = $sth_size->fetchrow_hashref()->{inc_size};

                                if ($db_size != $currSize) {
                                        $cont .= "NOT EQUAL!: [fs_size:$currSize, db_size:$db_size, backup_id:$backup_id] <br />";
                                }
                                
                                if ($currSize > 0) {
                                        $total_size += $currSize;
                                } 
                                $selected++;

                                my ($this_part) = $dbh->selectrow_array("select parts from backups where id = ?", undef, $backup_id);
                                $this_part--;
                                $parts += $this_part;
                        } 
                }

                if ($total_size > ($Conf{MaxArchiveSize} * $parts)) {
                        $cont .= eval( q{ ${h2(Error)}});
                        $cont .= "Selected backups size " . sprintf("%1.2f", $total_size / 1024) ." Kb exceed max archive size " . sprintf("%1.2f", $Conf{MaxArchiveSize} / 1024) ." Kb.";
                } elsif ($total_size == 0) {
                        $cont .= eval( q{ ${h2(Error)}});
                        $cont .= "No backups selected.";
                } else {

                        # create new archive
                        my $sth = $dbh->prepare(q{
                                INSERT INTO archive (
                                        id,
                                        dvd_nr,
                                        note,
                                        username,
                                        date,
                                        total_size
                                ) VALUES (
                                        nextVal('archive_id_seq'),
                                        nextVal('dvd_nr'),
                                        ?,
                                        ?,
                                        NOW(),
                                        ?
                                )
                        });

                        $sth->execute($In{'note'}, $User, $total_size);

                        foreach my $backup_id (@selected_backup_ids) {

                                # link backups with archive
                                my $sth = $dbh->prepare(q{
                                        INSERT INTO archive_backup (
                                                archive_id, backup_id
                                        ) VALUES (
                                                (SELECT last_value FROM archive_id_seq), ?
                                        )
                                });

                                $sth->execute($backup_id);

                                $dbh->commit();

                        }

                        my ($dvd_nr) = $dbh->selectrow_array(qq{
                                select last_value from dvd_nr
                        });

                        $dvd_nr ||= 'error';

                        $dbh->commit();

                        my $db_size = 0;
                        $sth = $dbh->prepare('SELECT SUM(gzip_size) AS suma FROM backups_on_dvds WHERE dvd_nr=?');
                        $sth->execute($dvd_nr);
                        $db_size = $sth->fetchrow_hashref()->{suma};
                        $sth->finish();
                        
                        $cont .= q{
                                Archived following backups:
                        } . join(", ", @selected_backup_ids) . q{
                                <br/>with total size of
                        <b>} . sprintf("%1.2f Mb", $total_size / 1024 / 1024) 
                        . q{</b>
                                to media <b>} . $dvd_nr . q{</b>
                                with following message:
                                <div style="background-color: #e0e0e0; display: inline; padding: 2px;">
                        } . $In{'note'} . q{
                                </div>
                        };
                }
        }

        Header($Lang->{Burn_media}, "", 1, "", $cont);

        Trailer();
        $dbh->disconnect();
}

1;
1	dpavlin	4	package BackupPC::CGI::BurnMedia;
2
3			use strict;
4			use BackupPC::CGI::Lib qw(:all);
5			use BackupPC::SearchLib;
6			use Data::Dumper;
7			use vars qw($Cgi %In $MyURL $User %Conf $TopDir $BinDir $bpc);
8
9	dpavlin	53	my $dsn = $Conf{SearchDSN};
10			my $db_user = $Conf{SearchUser} \|\| '';
11	dpavlin	4
12	dpavlin	53	sub action() {
13			my $cont = "";
14			my $title;
15			my $subtitle;
16			my @files;
17
18	iklaric	137	my $dbh = DBI->connect($dsn, $db_user, "", { RaiseError => 1, AutoCommit => 0 } );
19	dpavlin	53
20			BackupPC::CGI::Lib::NewRequest();
21	iklaric	121	# $cont = Dumper(%In);
22	dpavlin	53	if (!defined($In{submitBurner})) {
23			$title = eval(q{ ${h1($Lang->{Burn_media})}});
24			$cont = Dumper(%In);
25			$subtitle = eval(q{ ${h2($Lang->{Burn_media_select})}});
26			$cont = <<EOF;
27
28			$title
29			$subtitle
30	dpavlin	4
31			EOF
32
33	iklaric	121	$cont .= "Backups that have not been archived:<br>";
34	dpavlin	217	$cont .= BackupPC::SearchLib::displayBackupsGrid( \%In );
35	dpavlin	4
36	dpavlin	53	} else {
37	dpavlin	4
38	dpavlin	145	my @selected_backup_ids;
39
40	iklaric	144	my $total_size = 0;
41	dpavlin	197	my $selected = 0;
42
43	dpavlin	263	my $parts = 1;
44	iklaric	147	foreach my $key(keys(%In)) {
45			if ($key =~ m/^fcb([0-9]+)_([0-9]+)_([0-9]+)$/gi) {
46	iklaric	380
47	iklaric	147	my ($host_id, $backup_num, $backup_id) = ($1,$2,$3);
48			push @selected_backup_ids, $backup_id;
49	iklaric	382	my $currSize = BackupPC::SearchLib::getGzipSizeFromBackupID($backup_id);
50			my $sth_size = $dbh->prepare(q{select inc_size from backups where id = ?});
51			$sth_size -> execute( $backup_id );
52			my $db_size = $sth_size->fetchrow_hashref()->{inc_size};
53
54			if ($db_size != $currSize) {
55			$cont .= "NOT EQUAL!: [fs_size:$currSize, db_size:$db_size, backup_id:$backup_id] <br />";
56			}
57
58	iklaric	380	if ($currSize > 0) {
59	iklaric	382	$total_size += $currSize;
60			}
61	dpavlin	197	$selected++;
62	dpavlin	263
63			my ($this_part) = $dbh->selectrow_array("select parts from backups where id = ?", undef, $backup_id);
64			$this_part--;
65			$parts += $this_part;
66	iklaric	382	}
67			}
68	dpavlin	53
69	dpavlin	258	if ($total_size > ($Conf{MaxArchiveSize} * $parts)) {
70	iklaric	144	$cont .= eval( q{ ${h2(Error)}});
71	dpavlin	263	$cont .= "Selected backups size " . sprintf("%1.2f", $total_size / 1024) ." Kb exceed max archive size " . sprintf("%1.2f", $Conf{MaxArchiveSize} / 1024) ." Kb.";
72	dpavlin	197	} elsif ($total_size == 0) {
73			$cont .= eval( q{ ${h2(Error)}});
74			$cont .= "No backups selected.";
75	dpavlin	145	} else {
76	dpavlin	53
77	iklaric	148	# create new archive
78			my $sth = $dbh->prepare(q{
79	dpavlin	263	INSERT INTO archive (
80			id,
81			dvd_nr,
82			note,
83			username,
84			date,
85			total_size
86			) VALUES (
87			nextVal('archive_id_seq'),
88			nextVal('dvd_nr'),
89			?,
90			?,
91			NOW(),
92			?
93			)
94			});
95	iklaric	146
96	dpavlin	165	$sth->execute($In{'note'}, $User, $total_size);
97	iklaric	148
98	dpavlin	145	foreach my $backup_id (@selected_backup_ids) {
99	dpavlin	53
100	dpavlin	145	# link backups with archive
101			my $sth = $dbh->prepare(q{
102			INSERT INTO archive_backup (
103	dpavlin	154	archive_id, backup_id
104	dpavlin	145	) VALUES (
105	dpavlin	154	(SELECT last_value FROM archive_id_seq), ?
106	dpavlin	145	)
107			});
108
109	dpavlin	154	$sth->execute($backup_id);
110	dpavlin	145
111			$dbh->commit();
112
113	iklaric	144	}
114	dpavlin	150
115			my ($dvd_nr) = $dbh->selectrow_array(qq{
116			select last_value from dvd_nr
117			});
118
119			$dvd_nr \|\|= 'error';
120
121	iklaric	146	$dbh->commit();
122	dpavlin	150
123	iklaric	382	my $db_size = 0;
124			$sth = $dbh->prepare('SELECT SUM(gzip_size) AS suma FROM backups_on_dvds WHERE dvd_nr=?');
125			$sth->execute($dvd_nr);
126			$db_size = $sth->fetchrow_hashref()->{suma};
127			$sth->finish();
128
129	dpavlin	150	$cont .= q{
130			Archived following backups:
131			} . join(", ", @selected_backup_ids) . q{
132			<br/>with total size of
133	iklaric	382	<b>} . sprintf("%1.2f Mb", $total_size / 1024 / 1024)
134			. q{</b>
135	dpavlin	150	to media <b>} . $dvd_nr . q{</b>
136			with following message:
137			<div style="background-color: #e0e0e0; display: inline; padding: 2px;">
138			} . $In{'note'} . q{
139			</div>
140			};
141	iklaric	121	}
142	dpavlin	4	}
143	dpavlin	145
144	dpavlin	53	Header($Lang->{Burn_media}, "", 1, "", $cont);
145	dpavlin	145
146	dpavlin	53	Trailer();
147			$dbh->disconnect();
148			}
149	dpavlin	4
150			1;