PVE/ReplicationConfig.pm

   1 package PVE::ReplicationConfig;
   2
   3 use strict;
   4 use warnings;
   5 use Data::Dumper;
   6
   7 use PVE::Tools;
   8 use PVE::JSONSchema qw(get_standard_option);
   9 use PVE::INotify;
  10 use PVE::SectionConfig;
  11 use PVE::CalendarEvent;
  12
  13 use PVE::Cluster qw(cfs_register_file cfs_read_file cfs_write_file cfs_lock_file);
  14
  15 use base qw(PVE::SectionConfig);
  16
  17 my $replication_cfg_filename = 'replication.cfg';
  18
  19 cfs_register_file($replication_cfg_filename,
  20                   sub { __PACKAGE__->parse_config(@_); },
  21                   sub { __PACKAGE__->write_config(@_); });
  22
  23 PVE::JSONSchema::register_format('pve-replication-job-id',
  24                                  \&parse_replication_job_id);
  25 sub parse_replication_job_id {
  26     my ($id, $noerr) = @_;
  27
  28     my $msg = "invalid replication job id '$id'";
  29
  30     if ($id =~ m/^(\d+)-(\d+)$/) {
  31         my ($guest, $jobnum) = (int($1), int($2));
  32         die "$msg (guest IDs < 100 are reseved)\n" if $guest < 100;
  33         my $parsed_id = "$guest-$jobnum"; # use parsed integers
  34         return wantarray ? ($guest, $jobnum, $parsed_id) :  $parsed_id;
  35     }
  36
  37     return undef if $noerr;
  38
  39     die "$msg\n";
  40 }
  41
  42 PVE::JSONSchema::register_standard_option('pve-replication-id', {
  43     description => "Replication Job ID. The ID is composed of a Guest ID and a job number, separated by a hyphen, i.e. '<GUEST>-<JOBNUM>'.",
  44     type => 'string', format => 'pve-replication-job-id',
  45     pattern => '[1-9][0-9]{2,8}-\d{1,9}',
  46 });
  47
  48 my $defaultData = {
  49     propertyList => {
  50         type => { description => "Section type." },
  51         id => get_standard_option('pve-replication-id'),
  52         disable => {
  53             description => "Flag to disable/deactivate the entry.",
  54             type => 'boolean',
  55             optional => 1,
  56         },
  57         comment => {
  58             description => "Description.",
  59             type => 'string',
  60             optional => 1,
  61             maxLength => 4096,
  62         },
  63         remove_job => {
  64             description => "Mark the replication job for removal. The job will remove all local replication snapshots. When set to 'full', it also tries to remove replicated volumes on the target. The job then removes itself from the configuration file.",
  65             type => 'string',
  66             enum => ['local', 'full'],
  67             optional => 1,
  68         },
  69         rate => {
  70             description => "Rate limit in mbps (megabytes per second) as floating point number.",
  71             type => 'number',
  72             minimum => 1,
  73             optional => 1,
  74         },
  75         schedule => {
  76             description => "Storage replication schedule. The format is a subset of `systemd` calender events.",
  77             type => 'string', format => 'pve-calendar-event',
  78             maxLength => 128,
  79             default => '*/15',
  80             optional => 1,
  81         },
  82     },
  83 };
  84
  85 sub private {
  86     return $defaultData;
  87 }
  88
  89 sub parse_section_header {
  90     my ($class, $line) = @_;
  91
  92     if ($line =~ m/^(\S+):\s*(\d+)-(\d+)\s*$/) {
  93         my ($type, $guest, $subid) = (lc($1), int($2), int($3));
  94         my $id = "$guest-$subid"; # use parsed integers
  95         my $errmsg = undef; # set if you want to skip whole section
  96         eval { parse_replication_job_id($id); };
  97         $errmsg = $@ if $@;
  98         my $config = {};
  99         return ($type, $id, $errmsg, $config);
 100     }
 101     return undef;
 102 }
 103
 104 # Note: We want only one replication job per target to
 105 # avoid confusion. This method should return a string
 106 # which uniquely identifies the target.
 107 sub get_unique_target_id {
 108     my ($class, $data) = @_;
 109
 110     die "please overwrite in subclass";
 111 }
 112
 113 sub parse_config {
 114     my ($class, $filename, $raw) = @_;
 115
 116     my $cfg = $class->SUPER::parse_config($filename, $raw);
 117
 118     my $target_hash = {};
 119
 120     foreach my $id (sort keys %{$cfg->{ids}}) {
 121         my $data = $cfg->{ids}->{$id};
 122
 123         my ($guest, $jobnum) = parse_replication_job_id($id);
 124
 125         $data->{guest} = $guest;
 126         $data->{jobnum} = $jobnum;
 127         $data->{id} = $id;
 128
 129         $data->{comment} = PVE::Tools::decode_text($data->{comment})
 130             if defined($data->{comment});
 131
 132         my $plugin = $class->lookup($data->{type});
 133         my $tid = $plugin->get_unique_target_id($data);
 134         my $vmid = $data->{guest};
 135
 136         # should not happen, but we want to be sure
 137         if (defined($target_hash->{$vmid}->{$tid})) {
 138             warn "delete job $id: replication job for guest '$vmid' to target '$tid' already exists\n";
 139             delete $cfg->{ids}->{$id};
 140         }
 141         $target_hash->{$vmid}->{$tid} = 1;
 142    }
 143
 144     return $cfg;
 145 }
 146
 147 sub write_config {
 148     my ($class, $filename, $cfg) = @_;
 149
 150     my $target_hash = {};
 151
 152     foreach my $id (keys %{$cfg->{ids}}) {
 153         my $data = $cfg->{ids}->{$id};
 154
 155         my $plugin = $class->lookup($data->{type});
 156         my $tid = $plugin->get_unique_target_id($data);
 157         my $vmid = $data->{guest};
 158
 159         die "property 'guest' has wrong value\n" if $id !~ m/^\Q$vmid\E-/;
 160         die "replication job for guest '$vmid' to target '$tid' already exists\n"
 161             if defined($target_hash->{$vmid}->{$tid});
 162         $target_hash->{$vmid}->{$tid} = 1;
 163
 164         $data->{comment} = PVE::Tools::encode_text($data->{comment})
 165             if defined($data->{comment});
 166     }
 167
 168     $class->SUPER::write_config($filename, $cfg);
 169 }
 170
 171 sub new {
 172     my ($type) = @_;
 173
 174     my $class = ref($type) || $type;
 175
 176     my $cfg = cfs_read_file($replication_cfg_filename);
 177
 178     return bless $cfg, $class;
 179 }
 180
 181 sub write {
 182     my ($cfg) = @_;
 183
 184     cfs_write_file($replication_cfg_filename, $cfg);
 185 }
 186
 187 sub lock {
 188     my ($code, $errmsg) = @_;
 189
 190     cfs_lock_file($replication_cfg_filename, undef, $code);
 191     my $err = $@;
 192     if ($err) {
 193         $errmsg ? die "$errmsg: $err" : die $err;
 194     }
 195 }
 196
 197 sub check_for_existing_jobs {
 198     my ($cfg, $vmid, $noerr) = @_;
 199
 200     foreach my $id (keys %{$cfg->{ids}}) {
 201         my $data = $cfg->{ids}->{$id};
 202
 203         if ($data->{guest} == $vmid) {
 204             return 1 if $noerr;
 205             die "There is a replication job '$id' for guest '$vmid' - " .
 206                 "Please remove that first.\n"
 207         }
 208     }
 209
 210     return undef;
 211 }
 212
 213 sub find_local_replication_job {
 214     my ($cfg, $vmid, $target) = @_;
 215
 216     foreach my $id (keys %{$cfg->{ids}}) {
 217         my $data = $cfg->{ids}->{$id};
 218
 219         return $data if $data->{type} eq 'local' &&
 220             $data->{guest} == $vmid && $data->{target} eq $target;
 221     }
 222
 223     return undef;
 224 }
 225
 226 # switch local replication job target
 227 sub switch_replication_job_target {
 228     my ($vmid, $old_target, $new_target) = @_;
 229
 230     my $transfer_job = sub {
 231         my $cfg = PVE::ReplicationConfig->new();
 232         my $jobcfg = find_local_replication_job($cfg, $vmid, $old_target);
 233
 234         return if !$jobcfg;
 235
 236         $jobcfg->{target} = $new_target;
 237
 238         $cfg->write();
 239     };
 240
 241     lock($transfer_job);
 242 };
 243
 244 sub delete_job {
 245     my ($jobid) = @_;
 246
 247     my $code = sub {
 248         my $cfg = __PACKAGE__->new();
 249         delete $cfg->{ids}->{$jobid};
 250         $cfg->write();
 251     };
 252
 253     lock($code);
 254 }
 255
 256 package PVE::ReplicationConfig::Cluster;
 257
 258 use base qw(PVE::ReplicationConfig);
 259
 260 sub type {
 261     return 'local';
 262 }
 263
 264 sub properties {
 265     return {
 266         target => {
 267             description => "Target node.",
 268             type => 'string', format => 'pve-node',
 269         },
 270     };
 271 }
 272
 273 sub options {
 274     return {
 275         target => { fixed => 1, optional => 0 },
 276         disable => { optional => 1 },
 277         comment => { optional => 1 },
 278         rate => { optional => 1 },
 279         schedule => { optional => 1 },
 280         remove_job => { optional => 1 },
 281     };
 282 }
 283
 284 sub get_unique_target_id {
 285     my ($class, $data) = @_;
 286
 287     return "local/$data->{target}";
 288 }
 289
 290 PVE::ReplicationConfig::Cluster->register();
 291 PVE::ReplicationConfig->init();
 292
 293 1;