src/PMG/CLI/pmgdb.pm

   1 package PMG::CLI::pmgdb;
   2
   3 use strict;
   4 use warnings;
   5 use Data::Dumper;
   6 use Encode qw(encode);
   7
   8 use PVE::SafeSyslog;
   9 use PVE::Tools qw(extract_param);
  10 use PVE::INotify;
  11 use PVE::CLIHandler;
  12
  13 use PMG::Utils;
  14 use PMG::RESTEnvironment;
  15 use PMG::DBTools;
  16 use PMG::RuleDB;
  17 use PMG::Cluster;
  18 use PMG::ClusterConfig;
  19 use PMG::Statistic;
  20
  21 use PMG::API2::RuleDB;
  22
  23 use base qw(PVE::CLIHandler);
  24
  25 sub setup_environment {
  26     PMG::RESTEnvironment->setup_default_cli_env();
  27 }
  28
  29 sub print_objects {
  30     my ($ruledb, $og) = @_;
  31
  32     my $objects = $ruledb->load_group_objects ($og->{id});
  33
  34     foreach my $obj (@$objects) {
  35         my $type_text = $obj->otype_text();
  36         my $desc = encode('UTF-8', $obj->short_desc());
  37         print "    OBJECT $type_text $obj->{id}: $desc\n";
  38     }
  39 }
  40
  41 sub print_rule {
  42     my ($ruledb, $rule, $rule_status) = @_;
  43
  44     $ruledb->load_rule_attributes($rule);
  45
  46     return if !$rule->{active} && $rule_status eq 'active';
  47     return if $rule->{active} && $rule_status eq 'inactive';
  48
  49     my $direction = {
  50         0 => 'in',
  51         1 => 'out',
  52         2 => 'in+out',
  53     };
  54     my $active = $rule->{active} ? 'ACTIVE' : 'inactive';
  55     my $dir = $direction->{$rule->{direction}};
  56     my $rulename = encode('UTF-8', $rule->{name});
  57
  58     print "RULE $rule->{id} (prio: $rule->{priority}, $dir, $active): $rulename\n";
  59
  60     my $print_group = sub {
  61         my ($type, $og, $print_mode) = @_;
  62         my $oname = encode('UTF-8', $og->{name});
  63         my $mode = "";
  64         if ($print_mode) {
  65             my $and = $og->{and} // 0;
  66             my $invert = $og->{invert} // 0;
  67             $mode = " (and=$and, invert=$invert)";
  68         }
  69         print "  $type group $og->{id}${mode}: $oname\n";
  70         print_objects($ruledb, $og);
  71     };
  72
  73     my $print_type_mode = sub {
  74         my ($type) = @_;
  75         my $and = $rule->{"$type-and"};
  76         my $invert = $rule->{"$type-invert"};
  77         if (defined($and) || defined($invert)) {
  78             my $print_type = uc($type);
  79             print "  $print_type mode: and=" . ($and // 0) . " invert=". ($invert // 0) . "\n";
  80         }
  81     };
  82
  83     my ($from, $to, $when, $what, $action) =
  84         $ruledb->load_groups($rule);
  85
  86     $print_type_mode->("from") if scalar(@$from);
  87     foreach my $og (@$from) {
  88         $ruledb->load_group_attributes($og);
  89         $print_group->("FROM", $og, 1);
  90     }
  91     $print_type_mode->("to") if scalar(@$to);
  92     foreach my $og (@$to) {
  93         $ruledb->load_group_attributes($og);
  94         $print_group->("TO", $og, 1);
  95     }
  96     $print_type_mode->("when") if scalar(@$when);
  97     foreach my $og (@$when) {
  98         $ruledb->load_group_attributes($og);
  99         $print_group->("WHEN", $og, 1);
 100     }
 101     $print_type_mode->("what") if scalar(@$what);
 102     foreach my $og (@$what) {
 103         $ruledb->load_group_attributes($og);
 104         $print_group->("WHAT", $og, 1);
 105     }
 106     foreach my $og (@$action) {
 107         $print_group->("ACTION", $og);
 108     }
 109 }
 110
 111 __PACKAGE__->register_method ({
 112     name => 'dump',
 113     path => 'dump',
 114     method => 'GET',
 115     description => "Print the PMG rule database.",
 116     parameters => {
 117         additionalProperties => 0,
 118         properties => {
 119             rules => {
 120                 description => "Which rules should be printed",
 121                 type => 'string',
 122                 enum => [qw(all active inactive)],
 123                 default => 'all',
 124                 optional => 1,
 125             },
 126         },
 127     },
 128     returns => { type => 'null'},
 129     code => sub {
 130         my ($param) = @_;
 131
 132         my $rule_status = $param->{rules} // '';
 133         my $dbh = PMG::DBTools::open_ruledb("Proxmox_ruledb");
 134         my $ruledb = PMG::RuleDB->new($dbh);
 135
 136         my $rules = $ruledb->load_rules();
 137
 138         foreach my $rule (@$rules) {
 139             print_rule($ruledb, $rule, $rule_status);
 140         }
 141
 142         $ruledb->close();
 143
 144         return undef;
 145     }});
 146
 147
 148 __PACKAGE__->register_method ({
 149     name => 'delete',
 150     path => 'delete',
 151     method => 'DELETE',
 152     description => "Delete PMG rule database.",
 153     parameters => {
 154         additionalProperties => 0,
 155         properties => {},
 156     },
 157     returns => { type => 'null'},
 158     code => sub {
 159         my ($param) = @_;
 160
 161         my $list = PMG::DBTools::database_list();
 162
 163         my $dbname = "Proxmox_ruledb";
 164
 165         die "Database '$dbname' does not exist\n" if !$list->{$dbname};
 166
 167         syslog('info', "delete rule database");
 168
 169         PMG::DBTools::delete_ruledb($dbname);
 170
 171         return undef;
 172     }});
 173
 174 __PACKAGE__->register_method ({
 175     name => 'init',
 176     path => 'init',
 177     method => 'POST',
 178     description => "Initialize/Upgrade the PMG rule database.",
 179     parameters => {
 180         additionalProperties => 0,
 181         properties => {
 182             force => {
 183                 type => 'boolean',
 184                 description => "Delete existing database.",
 185                 optional => 1,
 186                 default => 0,
 187             },
 188             statistics => {
 189                 type => 'boolean',
 190                 description => "Reset and update statistic database.",
 191                 optional => 1,
 192                 default => 0,
 193             },
 194         }
 195     },
 196     returns => { type => 'null'},
 197     code => sub {
 198         my ($param) = @_;
 199
 200         PMG::Utils::cond_add_default_locale();
 201
 202         my $list = PMG::DBTools::database_list();
 203
 204         my $dbname = "Proxmox_ruledb";
 205
 206         if (!$list->{$dbname} || $param->{force}) {
 207
 208             if ($list->{$dbname}) {
 209                 print "Destroy existing rule database\n";
 210                 PMG::DBTools::delete_ruledb($dbname);
 211             }
 212
 213             print "Initialize rule database\n";
 214
 215             my $dbh = PMG::DBTools::create_ruledb ($dbname);
 216             my $ruledb = PMG::RuleDB->new($dbh);
 217             PMG::DBTools::init_ruledb($ruledb);
 218
 219             $dbh->disconnect();
 220
 221         } else {
 222
 223             my $dbh = PMG::DBTools::open_ruledb("Proxmox_ruledb");
 224             my $ruledb = PMG::RuleDB->new($dbh);
 225
 226             print "Analyzing/Upgrading existing Databases...";
 227             PMG::DBTools::upgradedb ($ruledb);
 228             print "done\n";
 229
 230             # reset and update statistic databases
 231             if ($param->{statistics}) {
 232                 print "Generating Proxmox Statistic Databases... ";
 233                 PMG::Statistic::clear_stats($dbh);
 234                 my $cinfo = PVE::INotify::read_file("cluster.conf");
 235                 PMG::Statistic::update_stats($dbh, $cinfo);
 236                 print "done\n";
 237             }
 238
 239             $dbh->disconnect();
 240         }
 241
 242         return undef;
 243     }});
 244
 245
 246 __PACKAGE__->register_method ({
 247     name => 'update',
 248     path => 'update',
 249     method => 'POST',
 250     description => "Update the PMG statistic database.",
 251     parameters => {
 252         additionalProperties => 0,
 253         properties => {},
 254     },
 255     returns => { type => 'null'},
 256     code => sub {
 257         my ($param) = @_;
 258
 259         my $dbh = PMG::DBTools::open_ruledb("Proxmox_ruledb");
 260         print "Updating Proxmox Statistic Databases... ";
 261         my $cinfo = PVE::INotify::read_file("cluster.conf");
 262         PMG::Statistic::update_stats($dbh, $cinfo);
 263         print "done\n";
 264         $dbh->disconnect();
 265
 266         return undef;
 267     }});
 268
 269 our $cmddef = {
 270     'dump' => [ __PACKAGE__, 'dump', []],
 271     delete => [ __PACKAGE__, 'delete', []],
 272     init => [ __PACKAGE__, 'init', []],
 273     reset => [ 'PMG::API2::RuleDB', 'reset_ruledb', []],
 274     update => [ __PACKAGE__, 'update', []],
 275 };
 276
 277 1;