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