run_command: add 'quiet' parameter for omitting STD* prints

[pve-common.git] / src / PVE / Tools.pm

diff --git a/src/PVE/Tools.pm b/src/PVE/Tools.pm
index 9ddcfda3444fde95fe76fad78b088986ec77177a..f91d35a1df52aa3a49acd8ebedf50147d08f8ceb 100644 (file)
--- a/src/PVE/Tools.pm
+++ b/src/PVE/Tools.pm
@@ -20,6 +20,7 @@ use base 'Exporter';
 use URI::Escape;
 use Encode;
 use Digest::SHA;
+use JSON;
 use Text::ParseWords;
 use String::ShellQuote;
 use Time::HiRes qw(usleep gettimeofday tv_interval alarm);
@@ -149,7 +150,7 @@ sub lock_file_full {
            or die "can't open file - $!\n";
 
        if (!flock($fh, $mode|LOCK_NB)) {
-           print STDERR "trying to acquire lock...";
+           print STDERR "trying to acquire lock...\n";
            my $success;
            while(1) {
                $success = flock($fh, $mode);
@@ -368,6 +369,7 @@ sub run_command {
     my $afterfork;
     my $noerr;
     my $keeplocale;
+    my $quiet;
 
     eval {
 
@@ -394,6 +396,8 @@ sub run_command {
                $noerr = $param{$p};
            } elsif ($p eq 'keeplocale') {
                $keeplocale = $param{$p};
+           } elsif ($p eq 'quiet') {
+               $quiet = $param{$p};
            } else {
                die "got unknown parameter '$p' for run_command\n";
            }
@@ -496,7 +500,7 @@ sub run_command {
                            waitpid ($pid, 0);
                            die $err;
                        }
-                   } else {
+                   } elsif (!$quiet) {
                        print $buf;
                        *STDOUT->flush();
                    }
@@ -516,7 +520,7 @@ sub run_command {
                            waitpid ($pid, 0);
                            die $err;
                        }
-                   } else {
+                   } elsif (!$quiet) {
                        print STDERR $buf;
                        *STDERR->flush();
                    }
@@ -790,17 +794,20 @@ sub extract_param {
 
 # Note: we use this to wait until vncterm/spiceterm is ready
 sub wait_for_vnc_port {
-    my ($port, $timeout) = @_;
+    my ($port, $family, $timeout) = @_;
 
     $timeout = 5 if !$timeout;
     my $sleeptime = 0;
     my $starttime = [gettimeofday];
     my $elapsed;
 
+    my $cmd = ['/bin/ss', '-Htln', "sport = :$port"];
+    push @$cmd, $family == AF_INET6 ? '-6' : '-4' if defined($family);
+
     my $found;
     while (($elapsed = tv_interval($starttime)) < $timeout) {
        # -Htln = don't print header, tcp, listening sockets only, numeric ports
-       run_command(['/bin/ss', '-Htln', "sport = :$port"], outfunc => sub {
+       run_command($cmd, outfunc => sub {
            my $line = shift;
            if ($line =~ m/^LISTEN\s+\d+\s+\d+\s+\S+:(\d+)\s/) {
                $found = 1 if ($port == $1);
@@ -811,7 +818,7 @@ sub wait_for_vnc_port {
        usleep($sleeptime);
     }
 
-    return undef;
+    die "Timeout while waiting for port '$port' to get ready!\n";
 }
 
 sub next_unused_port {
@@ -905,7 +912,6 @@ sub run_fork_with_timeout {
     my $res;
     my $error;
     my $pipe_out = IO::Pipe->new();
-    my $pipe_err = IO::Pipe->new();
 
     # disable pending alarms, save their remaining time
     my $prev_alarm = alarm 0;
@@ -922,35 +928,37 @@ sub run_fork_with_timeout {
 
     if (!$child) {
        $pipe_out->writer();
-       $pipe_err->writer();
 
        eval {
            $res = $sub->();
-           print {$pipe_out} "$res";
+           print {$pipe_out} encode_json({ result => $res });
            $pipe_out->flush();
        };
        if (my $err = $@) {
-           print {$pipe_err} "$err";
-           $pipe_err->flush();
+           print {$pipe_out} encode_json({ error => $err });
+           $pipe_out->flush();
            POSIX::_exit(1);
        }
        POSIX::_exit(0);
     }
 
     $pipe_out->reader();
-    $pipe_err->reader();
 
     my $readvalues = sub {
        local $/ = undef;
-       $res = <$pipe_out>;
-       $error = <$pipe_err>;
+       my $child_res = decode_json(scalar<$pipe_out>);
+       $res = $child_res->{result};
+       $error = $child_res->{error};
     };
     eval {
-       run_with_timeout($timeout, $readvalues);
+       if (defined($timeout)) {
+           run_with_timeout($timeout, $readvalues);
+       } else {
+           $readvalues->();
+       }
     };
     warn $@ if $@;
     $pipe_out->close();
-    $pipe_err->close();
     kill('KILL', $child);
     waitpid($child, 0);
 
@@ -961,6 +969,11 @@ sub run_fork_with_timeout {
     return $res;
 }
 
+sub run_fork {
+    my ($code) = @_;
+    return run_fork_with_timeout(undef, $code);
+}
+
 # NOTE: NFS syscall can't be interrupted, so alarm does
 # not work to provide timeouts.
 # from 'man nfs': "Only SIGKILL can interrupt a pending NFS operation"
@@ -985,7 +998,8 @@ sub df {
        $pipe->writer();
        eval {
            my $df = Filesys::Df::df($path, 1);
-           print {$pipe} "$df->{blocks}\n$df->{used}\n$df->{bavail}\n";
+           print {$pipe} "$df->{blocks}\n$df->{used}\n$df->{bavail}\n"
+               if defined($df);
            $pipe->close();
        };
        if (my $err = $@) {
@@ -998,9 +1012,9 @@ sub df {
     $pipe->reader();
 
     my $readvalues = sub {
-       $res->{total} = int((<$pipe> =~ /^(\d*)$/)[0]);
-       $res->{used}  = int((<$pipe> =~ /^(\d*)$/)[0]);
-       $res->{avail} = int((<$pipe> =~ /^(\d*)$/)[0]);
+       $res->{total} = int(((<$pipe> // 0) =~ /^(\d*)$/)[0]);
+       $res->{used}  = int(((<$pipe> // 0) =~ /^(\d*)$/)[0]);
+       $res->{avail} = int(((<$pipe> // 0) =~ /^(\d*)$/)[0]);
     };
     eval {
        run_with_timeout($timeout, $readvalues);
@@ -1617,4 +1631,45 @@ sub encrypt_pw {
     return crypt(encode("utf8", $pw), "\$5\$$salt\$");
 }
 
+# intended usage: convert_size($val, "kb" => "gb")
+# we round up to the next integer by default
+# E.g. `convert_size(1023, "b" => "kb")` returns 1
+# use $no_round_up to switch this off, above example would then return 0
+# this is also true for converting down e.g. 0.0005 gb to mb returns 1
+# (0 if $no_round_up is true)
+# allowed formats for value:
+# 1234
+# 1234.
+# 1234.1234
+# .1234
+sub convert_size {
+    my ($value, $from, $to, $no_round_up) = @_;
+
+    my $units = {
+       b  => 0,
+       kb => 1,
+       mb => 2,
+       gb => 3,
+       tb => 4,
+       pb => 5,
+    };
+
+    die "no value given"
+       if !defined($value) || $value eq "";
+
+    $from = lc($from // ''); $to = lc($to // '');
+    die "unknown 'from' and/or 'to' units ($from => $to)"
+       if !defined($units->{$from}) || !defined($units->{$to});
+
+    die "value '$value' is not a valid, positive number"
+       if $value !~ m/^(?:[0-9]+\.?[0-9]*|[0-9]*\.[0-9]+)$/;
+
+    my $shift_amount = ($units->{$from} - $units->{$to}) * 10;
+
+    $value *= 2**$shift_amount;
+    $value++ if !$no_round_up && ($value - int($value)) > 0.0;
+
+    return int($value);
+}
+
 1;