PMG/API2/Services.pm

   1 package PMG::API2::Services;
   2
   3 use strict;
   4 use warnings;
   5
   6 use PVE::Tools;
   7 use PVE::SafeSyslog;
   8 use PVE::INotify;
   9 use PVE::Exception qw(raise_param_exc);
  10 use PVE::RESTHandler;
  11 use PVE::RESTEnvironment;
  12 use PVE::JSONSchema qw(get_standard_option);
  13
  14 use PMG::Utils;
  15
  16 use base qw(PVE::RESTHandler);
  17
  18 my $service_name_list = [
  19     'clamav-daemon',
  20     'clamav-freshclam',
  21     'pmgproxy',
  22     'pmgdaemon',
  23     'pmgpolicy',
  24     'pmg-smtp-filter',
  25     'sshd',
  26     'syslog',
  27     'cron',
  28     'postfix',
  29     'systemd-timesyncd',
  30     ];
  31
  32 my $get_full_service_state = sub {
  33     my ($service) = @_;
  34
  35     my $res;
  36
  37     my $parser = sub {
  38         my $line = shift;
  39         if ($line =~ m/^([^=\s]+)=(.*)$/) {
  40             $res->{$1} = $2;
  41         }
  42     };
  43
  44     $service = 'postfix@-' if $service eq 'postfix';
  45     PVE::Tools::run_command(['systemctl', 'show', $service], outfunc => $parser);
  46
  47     return $res;
  48 };
  49
  50 my $static_service_list;
  51
  52 sub get_service_list {
  53
  54     return $static_service_list if $static_service_list;
  55
  56     my $list = {};
  57     foreach my $name (@$service_name_list) {
  58         my $ss;
  59         eval { $ss = &$get_full_service_state($name); };
  60         warn $@ if $@;
  61         next if !$ss;
  62         next if !defined($ss->{Description});
  63         $list->{$name} = { name => $name, desc =>  $ss->{Description} };
  64     }
  65
  66     $static_service_list = $list;
  67
  68     return $static_service_list;
  69 }
  70
  71
  72 my $service_prop_desc = {
  73     description => "Service ID",
  74     type => 'string',
  75     enum => $service_name_list,
  76 };
  77
  78 my $service_state = sub {
  79     my ($service) = @_;
  80
  81     my $ss;
  82     eval { $ss = &$get_full_service_state($service); };
  83     if (my $err = $@) {
  84         return 'unknown';
  85     }
  86
  87     return $ss->{SubState} if $ss->{SubState};
  88
  89     return 'unknown';
  90 };
  91
  92 __PACKAGE__->register_method ({
  93     name => 'index',
  94     path => '',
  95     method => 'GET',
  96     description => "Service list.",
  97     proxyto => 'node',
  98     protected => 1,
  99     parameters => {
 100         additionalProperties => 0,
 101         properties => {
 102             node => get_standard_option('pve-node'),
 103         },
 104     },
 105     returns => {
 106         type => 'array',
 107         items => {
 108             type => "object",
 109             properties => {},
 110         },
 111         links => [ { rel => 'child', href => "{service}" } ],
 112     },
 113     code => sub {
 114         my ($param) = @_;
 115
 116         my $res = [];
 117
 118         my $service_list = get_service_list();
 119
 120         foreach my $id (keys %{$service_list}) {
 121             push @$res, {
 122                 service => $id,
 123                 name => $service_list->{$id}->{name},
 124                 desc => $service_list->{$id}->{desc},
 125                 state => &$service_state($id),
 126             };
 127         }
 128
 129         return $res;
 130     }});
 131
 132 __PACKAGE__->register_method({
 133     name => 'srvcmdidx',
 134     path => '{service}',
 135     method => 'GET',
 136     description => "Directory index",
 137     parameters => {
 138         additionalProperties => 0,
 139         properties => {
 140             node => get_standard_option('pve-node'),
 141             service => $service_prop_desc,
 142         },
 143     },
 144     returns => {
 145         type => 'array',
 146         items => {
 147             type => "object",
 148             properties => {
 149                 subdir => { type => 'string' },
 150             },
 151         },
 152         links => [ { rel => 'child', href => "{subdir}" } ],
 153     },
 154     code => sub {
 155         my ($param) = @_;
 156
 157         my $res = [
 158             { subdir => 'state' },
 159             { subdir => 'start' },
 160             { subdir => 'stop' },
 161             { subdir => 'restart' },
 162             { subdir => 'reload' },
 163             ];
 164
 165         return $res;
 166     }});
 167
 168 __PACKAGE__->register_method ({
 169     name => 'service_state',
 170     path => '{service}/state',
 171     method => 'GET',
 172     description => "Read service properties",
 173     proxyto => 'node',
 174     protected => 1,
 175     parameters => {
 176         additionalProperties => 0,
 177         properties => {
 178             node => get_standard_option('pve-node'),
 179             service => $service_prop_desc,
 180         },
 181     },
 182     returns => {
 183         type => "object",
 184         properties => {},
 185     },
 186     code => sub {
 187         my ($param) = @_;
 188
 189         my $service_list = get_service_list();
 190
 191         my $si = $service_list->{$param->{service}};
 192         return {
 193             service => $param->{service},
 194             name => $si->{name},
 195             desc => $si->{desc},
 196             state => &$service_state($param->{service}),
 197         };
 198     }});
 199
 200 __PACKAGE__->register_method ({
 201     name => 'service_start',
 202     path => '{service}/start',
 203     method => 'POST',
 204     description => "Start service.",
 205     proxyto => 'node',
 206     protected => 1,
 207     parameters => {
 208         additionalProperties => 0,
 209         properties => {
 210             node => get_standard_option('pve-node'),
 211             service => $service_prop_desc,
 212         },
 213     },
 214     returns => {
 215         type => 'string',
 216     },
 217     code => sub {
 218         my ($param) = @_;
 219
 220         my $restenv = PVE::RESTEnvironment::get();
 221
 222         my $user = $restenv->get_user();
 223
 224         my $realcmd = sub {
 225             my $upid = shift;
 226
 227             syslog('info', "starting service $param->{service}: $upid\n");
 228
 229             PMG::Utils::service_cmd($param->{service}, 'start');
 230
 231         };
 232
 233         return $restenv->fork_worker('srvstart', $param->{service}, $user, $realcmd);
 234     }});
 235
 236 __PACKAGE__->register_method ({
 237     name => 'service_stop',
 238     path => '{service}/stop',
 239     method => 'POST',
 240     description => "Stop service.",
 241     proxyto => 'node',
 242     protected => 1,
 243     parameters => {
 244         additionalProperties => 0,
 245         properties => {
 246             node => get_standard_option('pve-node'),
 247             service => $service_prop_desc,
 248         },
 249     },
 250     returns => {
 251         type => 'string',
 252     },
 253     code => sub {
 254         my ($param) = @_;
 255
 256         my $restenv = PVE::RESTEnvironment::get();
 257
 258         my $user = $restenv->get_user();
 259
 260         my $realcmd = sub {
 261             my $upid = shift;
 262
 263             syslog('info', "stoping service $param->{service}: $upid\n");
 264
 265             PMG::Utils::service_cmd($param->{service}, 'stop');
 266
 267         };
 268
 269         return $restenv->fork_worker('srvstop', $param->{service}, $user, $realcmd);
 270     }});
 271
 272 __PACKAGE__->register_method ({
 273     name => 'service_restart',
 274     path => '{service}/restart',
 275     method => 'POST',
 276     description => "Restart service.",
 277     proxyto => 'node',
 278     protected => 1,
 279     parameters => {
 280         additionalProperties => 0,
 281         properties => {
 282             node => get_standard_option('pve-node'),
 283             service => $service_prop_desc,
 284         },
 285     },
 286     returns => {
 287         type => 'string',
 288     },
 289     code => sub {
 290         my ($param) = @_;
 291
 292         my $restenv = PVE::RESTEnvironment::get();
 293
 294         my $user = $restenv->get_user();
 295
 296         my $realcmd = sub {
 297             my $upid = shift;
 298
 299             syslog('info', "re-starting service $param->{service}: $upid\n");
 300
 301             PMG::Utils::service_cmd($param->{service}, 'restart');
 302
 303         };
 304
 305         return $restenv->fork_worker('srvrestart', $param->{service}, $user, $realcmd);
 306     }});
 307
 308 __PACKAGE__->register_method ({
 309     name => 'service_reload',
 310     path => '{service}/reload',
 311     method => 'POST',
 312     description => "Reload service.",
 313     proxyto => 'node',
 314     protected => 1,
 315     parameters => {
 316         additionalProperties => 0,
 317         properties => {
 318             node => get_standard_option('pve-node'),
 319             service => $service_prop_desc,
 320         },
 321     },
 322     returns => {
 323         type => 'string',
 324     },
 325     code => sub {
 326         my ($param) = @_;
 327
 328         my $restenv = PVE::RESTEnvironment::get();
 329
 330         my $user = $restenv->get_user();
 331
 332         my $realcmd = sub {
 333             my $upid = shift;
 334
 335             syslog('info', "reloading service $param->{service}: $upid\n");
 336
 337             PMG::Utils::service_cmd($param->{service}, 'reload');
 338
 339         };
 340
 341         return $restenv->fork_worker('srvreload', $param->{service}, $user, $realcmd);
 342     }});