src/PVE/HA/Config.pm

   1 package PVE::HA::Config;
   2
   3 use strict;
   4 use warnings;
   5 use JSON;
   6
   7 use PVE::HA::Tools;
   8 use PVE::HA::Groups;
   9 use PVE::Cluster qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
  10 use PVE::HA::Resources;
  11
  12 my $manager_status_filename = "ha/manager_status";
  13 my $ha_groups_config = "ha/groups.cfg";
  14 my $ha_resources_config = "ha/resources.cfg";
  15 my $crm_commands_filename = "ha/crm_commands";
  16 my $ha_fence_config = "ha/fence.cfg";
  17
  18 cfs_register_file($crm_commands_filename,
  19                   sub { my ($fn, $raw) = @_; return defined($raw) ? $raw : ''; },
  20                   sub { my ($fn, $raw) = @_; return $raw; });
  21 cfs_register_file($ha_groups_config,
  22                   sub { PVE::HA::Groups->parse_config(@_); },
  23                   sub { PVE::HA::Groups->write_config(@_); });
  24 cfs_register_file($ha_resources_config,
  25                   sub { PVE::HA::Resources->parse_config(@_); },
  26                   sub { PVE::HA::Resources->write_config(@_); });
  27 cfs_register_file($manager_status_filename,
  28                   \&json_reader,
  29                   \&json_writer);
  30 cfs_register_file($ha_fence_config,
  31                   \&PVE::HA::FenceConfig::parse_config,
  32                   \&PVE::HA::FenceConfig::write_config);
  33
  34 sub json_reader {
  35     my ($filename, $data) = @_;
  36
  37     return defined($data) && length($data) > 0 ? decode_json($data) : {};
  38 }
  39
  40 sub json_writer {
  41     my ($filename, $data) = @_;
  42
  43     return encode_json($data);
  44 }
  45
  46 sub read_lrm_status {
  47     my ($node) = @_;
  48
  49     die "undefined node" if !defined($node);
  50
  51     my $cfs_path = "nodes/$node/lrm_status";
  52
  53     my $raw = PVE::Cluster::get_config($cfs_path);
  54     if (!defined($raw)) {
  55         # ENOENT -> possible deleted node, don't die here as it breaks our node
  56         # 'gone' logic
  57         warn "unable to read file '/etc/pve/$cfs_path'\n";
  58         # unkown mode set explicitly as 'active' is assumed as default..
  59         return { mode => 'unknown' } if ! -e "/etc/pve/$cfs_path";
  60     }
  61
  62     return json_reader(undef, $raw);
  63 }
  64
  65 sub write_lrm_status {
  66     my ($node, $status_obj) = @_;
  67
  68     die "undefined node" if !defined($node);
  69
  70     my $filename = "/etc/pve/nodes/$node/lrm_status";
  71
  72     PVE::HA::Tools::write_json_to_file($filename, $status_obj);
  73 }
  74
  75 sub parse_groups_config {
  76     my ($filename, $raw) = @_;
  77
  78     return PVE::HA::Groups->parse_config($filename, $raw);
  79 }
  80
  81 sub parse_resources_config {
  82     my ($filename, $raw) = @_;
  83
  84     return PVE::HA::Resources->parse_config($filename, $raw);
  85 }
  86
  87 sub read_resources_config {
  88
  89     return cfs_read_file($ha_resources_config);
  90 }
  91
  92 # checks if resource exists and sets defaults for unset values
  93 sub read_and_check_resources_config {
  94
  95     my $res = cfs_read_file($ha_resources_config);
  96
  97     my $vmlist = PVE::Cluster::get_vmlist();
  98     my $conf = {};
  99
 100     foreach my $sid (keys %{$res->{ids}}) {
 101         my $d = $res->{ids}->{$sid};
 102         my (undef, undef, $name) = parse_sid($sid);
 103         $d->{state} = 'started' if !defined($d->{state});
 104         $d->{state} = 'started' if $d->{state} eq 'enabled'; # backward compatibility
 105         $d->{max_restart} = 1 if !defined($d->{max_restart});
 106         $d->{max_relocate} = 1 if !defined($d->{max_relocate});
 107         if (PVE::HA::Resources->lookup($d->{type})) {
 108             if (my $vmd = $vmlist->{ids}->{$name}) {
 109                 if (!$vmd) {
 110                     warn "no such VM '$name'\n";
 111                 } else {
 112                     $d->{node} = $vmd->{node};
 113                     $conf->{$sid} = $d;
 114                 }
 115             } else {
 116                 if (defined($d->{node})) {
 117                     $conf->{$sid} = $d;
 118                 } else {
 119                     warn "service '$sid' without node\n";
 120                 }
 121             }
 122         }
 123     }
 124
 125     return $conf;
 126 }
 127
 128 sub parse_sid {
 129     my ($sid) = @_;
 130
 131     my ($type, $name);
 132
 133     if ($sid =~ m/^(\d+)$/) {
 134         $name = $1;
 135
 136         my $vmlist = PVE::Cluster::get_vmlist();
 137         if (defined($vmlist->{ids}->{$name})) {
 138             my $vm_type = $vmlist->{ids}->{$name}->{type};
 139             if ($vm_type eq 'lxc') {
 140                 $type = 'ct';
 141             } elsif ($vm_type eq 'qemu') {
 142                 $type = 'vm';
 143             } else {
 144                 die "internal error";
 145             }
 146             $sid = "$type:$name";
 147         }
 148         else {
 149             die "unable do add resource - VM/CT $1 does not exist\n";
 150         }
 151     } elsif ($sid =~m/^(\S+):(\S+)$/) {
 152         $name = $2;
 153         $type = $1;
 154     } else {
 155         die "unable to parse service id '$sid'\n";
 156     }
 157
 158     return wantarray ? ($sid, $type, $name) : $sid;
 159 }
 160
 161 sub read_group_config {
 162
 163     return cfs_read_file($ha_groups_config);
 164 }
 165
 166 sub write_group_config {
 167     my ($cfg) = @_;
 168
 169     cfs_write_file($ha_groups_config, $cfg);
 170 }
 171
 172 sub write_resources_config {
 173     my ($cfg) = @_;
 174
 175     cfs_write_file($ha_resources_config, $cfg);
 176 }
 177
 178 sub read_manager_status {
 179     my () = @_;
 180
 181     return cfs_read_file($manager_status_filename);
 182 }
 183
 184 sub write_manager_status {
 185     my ($status_obj) = @_;
 186
 187     cfs_write_file($manager_status_filename, $status_obj);
 188 }
 189
 190 sub read_fence_config {
 191     my () = @_;
 192
 193     cfs_read_file($ha_fence_config);
 194 }
 195
 196 sub write_fence_config {
 197     my ($cfg) = @_;
 198
 199     cfs_write_file($ha_fence_config, $cfg);
 200 }
 201
 202 sub lock_ha_domain {
 203     my ($code, $errmsg) = @_;
 204
 205     my $res = PVE::Cluster::cfs_lock_domain("ha", undef, $code);
 206     my $err = $@;
 207     if ($err) {
 208         $errmsg ? die "$errmsg: $err" : die $err;
 209     }
 210     return $res;
 211 }
 212
 213 sub queue_crm_commands {
 214     my ($cmd) = @_;
 215
 216     chomp $cmd;
 217
 218     my $code = sub {
 219         my $data = cfs_read_file($crm_commands_filename);
 220         $data .= "$cmd\n";
 221         cfs_write_file($crm_commands_filename, $data);
 222     };
 223
 224     return lock_ha_domain($code);
 225 }
 226
 227 sub read_crm_commands {
 228
 229     my $code = sub {
 230         my $data = cfs_read_file($crm_commands_filename);
 231         cfs_write_file($crm_commands_filename, '');
 232         return $data;
 233     };
 234
 235     return lock_ha_domain($code);
 236 }
 237
 238 my $service_check_ha_state = sub {
 239     my ($conf, $sid, $has_state) = @_;
 240
 241     if (my $d = $conf->{ids}->{$sid}) {
 242         if (!defined($has_state)) {
 243             # ignored service behave as if they were not managed by HA
 244             return 0 if defined($d->{state}) && $d->{state} eq 'ignored';
 245             return 1;
 246         }
 247
 248         # backward compatibility
 249         $has_state = 'started' if $has_state eq 'enabled';
 250
 251         $d->{state} = 'started' if !defined($d->{state}) ||
 252             ($d->{state} eq 'enabled');
 253
 254         return 1 if $d->{state} eq $has_state;
 255     }
 256
 257     return undef;
 258 };
 259
 260 sub vm_is_ha_managed {
 261     my ($vmid, $has_state) = @_;
 262
 263     my $conf = cfs_read_file($ha_resources_config);
 264
 265     my $types = PVE::HA::Resources->lookup_types();
 266     foreach my $type ('vm', 'ct') {
 267         return 1 if &$service_check_ha_state($conf, "$type:$vmid", $has_state);
 268     }
 269
 270     return undef;
 271 }
 272
 273 sub service_is_ha_managed {
 274     my ($sid, $has_state, $noerr) = @_;
 275
 276     my $conf = cfs_read_file($ha_resources_config);
 277
 278     return 1 if &$service_check_ha_state($conf, $sid, $has_state);
 279
 280     die "resource '$sid' is not HA managed\n" if !$noerr;
 281
 282     return undef;
 283 }
 284
 285 sub get_service_status {
 286     my ($sid) = @_;
 287
 288     my $status = { managed => 0 };
 289
 290     my $conf = cfs_read_file($ha_resources_config);
 291
 292     if (&$service_check_ha_state($conf, $sid)) {
 293         my $manager_status = cfs_read_file($manager_status_filename);
 294
 295         $status->{managed} = 1;
 296         $status->{group} = $conf->{ids}->{$sid}->{group};
 297         $status->{state} = $manager_status->{service_status}->{$sid}->{state};
 298     }
 299
 300     return $status;
 301 }
 302
 303 1;