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