data/PVE/CLI/pvecm.pm

   1 package PVE::CLI::pvecm;
   2
   3 use strict;
   4 use warnings;
   5 use Getopt::Long;
   6 use Socket;
   7 use IO::File;
   8 use Net::IP;
   9 use File::Path;
  10 use File::Basename;
  11 use Data::Dumper; # fixme: remove
  12 use PVE::Tools;
  13 use PVE::Cluster;
  14 use PVE::INotify;
  15 use PVE::JSONSchema;
  16 use PVE::CLIHandler;
  17
  18 use base qw(PVE::CLIHandler);
  19
  20 $ENV{HOME} = '/root'; # for ssh-copy-id
  21
  22 my $basedir = "/etc/pve";
  23 my $clusterconf = "$basedir/corosync.conf";
  24 my $libdir = "/var/lib/pve-cluster";
  25 my $backupdir = "/var/lib/pve-cluster/backup";
  26 my $dbfile = "$libdir/config.db";
  27 my $authfile = "/etc/corosync/authkey";
  28
  29 sub backup_database {
  30
  31     print "backup old database\n";
  32
  33     mkdir $backupdir;
  34
  35     my $ctime = time();
  36     my $cmd = [
  37         ['echo', '.dump'],
  38         ['sqlite3', $dbfile],
  39         ['gzip', '-', \ ">${backupdir}/config-${ctime}.sql.gz"],
  40     ];
  41
  42     PVE::Tools::run_command($cmd, 'errmsg' => "cannot backup old database\n");
  43
  44     # purge older backup
  45     my $maxfiles = 10;
  46
  47     my @bklist = ();
  48     foreach my $fn (<$backupdir/config-*.sql.gz>) {
  49         if ($fn =~ m!/config-(\d+)\.sql.gz$!) {
  50             push @bklist, [$fn, $1];
  51         }
  52     }
  53
  54     @bklist = sort { $b->[1] <=> $a->[1] } @bklist;
  55
  56     while (scalar (@bklist) >= $maxfiles) {
  57         my $d = pop @bklist;
  58         print "delete old backup '$d->[0]'\n";
  59         unlink $d->[0];
  60     }
  61 }
  62
  63 __PACKAGE__->register_method ({
  64     name => 'keygen',
  65     path => 'keygen',
  66     method => 'PUT',
  67     description => "Generate new cryptographic key for corosync.",
  68     parameters => {
  69         additionalProperties => 0,
  70         properties => {
  71             filename => {
  72                 type => 'string',
  73                 description => "Output file name"
  74             }
  75         },
  76     },
  77     returns => { type => 'null' },
  78
  79     code => sub {
  80         my ($param) = @_;
  81
  82         my $filename = $param->{filename};
  83
  84         # test EUID
  85         $> == 0 || die "Error: Authorization key must be generated as root user.\n";
  86         my $dirname = dirname($filename);
  87         my $basename = basename($filename);
  88
  89         die "key file '$filename' already exists\n" if -e $filename;
  90
  91         File::Path::make_path($dirname) if $dirname;
  92
  93         my $cmd = ['corosync-keygen', '-l', '-k', $filename];
  94         PVE::Tools::run_command($cmd);
  95
  96         return undef;
  97     }});
  98
  99 __PACKAGE__->register_method ({
 100     name => 'create',
 101     path => 'create',
 102     method => 'PUT',
 103     description => "Generate new cluster configuration.",
 104     parameters => {
 105         additionalProperties => 0,
 106         properties => {
 107             clustername => {
 108                 description => "The name of the cluster.",
 109                 type => 'string', format => 'pve-node',
 110                 maxLength => 15,
 111             },
 112             nodeid => {
 113                 type => 'integer',
 114                 description => "Node id for this node.",
 115                 minimum => 1,
 116                 optional => 1,
 117             },
 118             votes => {
 119                 type => 'integer',
 120                 description => "Number of votes for this node.",
 121                 minimum => 1,
 122                 optional => 1,
 123             },
 124             bindnet0_addr => {
 125                 type => 'string', format => 'ip',
 126                 description => "This specifies the network address the corosync ring 0".
 127                     " executive should bind to and defaults to the local IP address of the node.",
 128                 optional => 1,
 129             },
 130             ring0_addr => {
 131                 type => 'string', format => 'address',
 132                 description => "Hostname (or IP) of the corosync ring0 address of this node.".
 133                     " Defaults to the hostname of the node.",
 134                 optional => 1,
 135             },
 136             bindnet1_addr => {
 137                 type => 'string', format => 'ip',
 138                 description => "This specifies the network address the corosync ring 1".
 139                     " executive should bind to and is optional.",
 140                 optional => 1,
 141             },
 142             ring1_addr => {
 143                 type => 'string', format => 'address',
 144                 description => "Hostname (or IP) of the corosync ring1 address, this".
 145                     " needs an valid bindnet1_addr.",
 146                 optional => 1,
 147             },
 148         },
 149     },
 150     returns => { type => 'null' },
 151
 152     code => sub {
 153         my ($param) = @_;
 154
 155         -f $clusterconf && die "cluster config '$clusterconf' already exists\n";
 156
 157         PVE::Cluster::setup_sshd_config(1);
 158         PVE::Cluster::setup_rootsshconfig();
 159         PVE::Cluster::setup_ssh_keys();
 160
 161         -f $authfile || __PACKAGE__->keygen({filename => $authfile});
 162
 163         -f $authfile || die "no authentication key available\n";
 164
 165         my $clustername = $param->{clustername};
 166
 167         $param->{nodeid} = 1 if !$param->{nodeid};
 168
 169         $param->{votes} = 1 if !defined($param->{votes});
 170
 171         my $nodename = PVE::INotify::nodename();
 172
 173         my $local_ip_address = PVE::Cluster::remote_node_ip($nodename);
 174
 175         $param->{bindnet0_addr} = $local_ip_address
 176             if !defined($param->{bindnet0_addr});
 177
 178         $param->{ring0_addr} = $nodename if !defined($param->{ring0_addr});
 179
 180         die "Param bindnet1_addr and ring1_addr are dependend, use both or none!\n"
 181             if (defined($param->{bindnet1_addr}) != defined($param->{ring1_addr}));
 182
 183         my $bind_is_ipv6 = Net::IP::ip_is_ipv6($param->{bindnet0_addr});
 184
 185         # use string as here-doc format distracts more
 186         my $interfaces = "interface {\n    ringnumber: 0\n" .
 187             "    bindnetaddr: $param->{bindnet0_addr}\n  }";
 188
 189         my $ring_addresses = "ring0_addr: $param->{ring0_addr}" ;
 190
 191         # allow use of multiple rings (rrp) at cluster creation time
 192         if ($param->{bindnet1_addr}) {
 193             die "IPv6 and IPv4 cannot be mixed, use one or the other!\n"
 194                 if Net::IP::ip_is_ipv6($param->{bindnet1_addr}) != $bind_is_ipv6;
 195
 196             $interfaces .= "\n  interface {\n    ringnumber: 1\n" .
 197                 "    bindnetaddr: $param->{bindnet1_addr}\n  }\n";
 198
 199             $interfaces .= "rrp_mode: passive\n"; # only passive is stable and tested
 200
 201             $ring_addresses .= "\n    ring1_addr: $param->{ring1_addr}";
 202
 203         } elsif($param->{rrp_mode} && $param->{rrp_mode} ne 'none') {
 204
 205             warn "rrp_mode '$param->{rrp_mode}' useless when using only one".
 206                 " ring, using 'none' instead";
 207             # corosync defaults to none if only one interface is configured
 208             $param->{rrp_mode} = undef;
 209
 210         }
 211
 212         # No, corosync cannot deduce this on its own
 213         my $ipversion = $bind_is_ipv6 ? 'ipv6' : 'ipv4';
 214
 215         my $config = <<_EOD;
 216 totem {
 217   version: 2
 218   secauth: on
 219   cluster_name: $clustername
 220   config_version: 1
 221   ip_version: $ipversion
 222   $interfaces
 223 }
 224
 225 nodelist {
 226   node {
 227     $ring_addresses
 228     name: $nodename
 229     nodeid: $param->{nodeid}
 230     quorum_votes: $param->{votes}
 231   }
 232 }
 233
 234 quorum {
 235   provider: corosync_votequorum
 236 }
 237
 238 logging {
 239   to_syslog: yes
 240   debug: off
 241 }
 242 _EOD
 243 ;
 244         PVE::Tools::file_set_contents($clusterconf, $config);
 245
 246         PVE::Cluster::ssh_merge_keys();
 247
 248         PVE::Cluster::gen_pve_node_files($nodename, $local_ip_address);
 249
 250         PVE::Cluster::ssh_merge_known_hosts($nodename, $local_ip_address, 1);
 251
 252         PVE::Tools::run_command('systemctl restart pve-cluster'); # restart
 253
 254         PVE::Tools::run_command('systemctl restart corosync'); # restart
 255
 256         return undef;
 257 }});
 258
 259 __PACKAGE__->register_method ({
 260     name => 'addnode',
 261     path => 'addnode',
 262     method => 'PUT',
 263     description => "Adds a node to the cluster configuration.",
 264     parameters => {
 265         additionalProperties => 0,
 266         properties => {
 267             node => PVE::JSONSchema::get_standard_option('pve-node'),
 268             nodeid => {
 269                 type => 'integer',
 270                 description => "Node id for this node.",
 271                 minimum => 1,
 272                 optional => 1,
 273             },
 274             votes => {
 275                 type => 'integer',
 276                 description => "Number of votes for this node",
 277                 minimum => 0,
 278                 optional => 1,
 279             },
 280             force => {
 281                 type => 'boolean',
 282                 description => "Do not throw error if node already exists.",
 283                 optional => 1,
 284             },
 285             ring0_addr => {
 286                 type => 'string', format => 'address',
 287                 description => "Hostname (or IP) of the corosync ring0 address of this node.".
 288                     " Defaults to nodes hostname.",
 289                 optional => 1,
 290             },
 291             ring1_addr => {
 292                 type => 'string', format => 'address',
 293                 description => "Hostname (or IP) of the corosync ring1 address, this".
 294                     " needs an valid bindnet1_addr.",
 295                 optional => 1,
 296             },
 297         },
 298     },
 299     returns => { type => 'null' },
 300
 301     code => sub {
 302         my ($param) = @_;
 303
 304         if (!$param->{force} && (-t STDIN || -t STDOUT)) {
 305             die "error: `addnode` should not get called interactively!\nUse ".
 306                 "`pvecm add <cluster-node>` to add a node to a cluster!\n";
 307         }
 308
 309         PVE::Cluster::check_cfs_quorum();
 310
 311         my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
 312
 313         my $nodelist = PVE::Cluster::corosync_nodelist($conf);
 314
 315         my $totem_cfg = PVE::Cluster::corosync_totem_config($conf);
 316
 317         my $name = $param->{node};
 318
 319         # ensure we do not reuse an address, that can crash the whole cluster!
 320         my $check_duplicate_addr = sub {
 321             my $addr = shift;
 322             return if !defined($addr);
 323
 324             while (my ($k, $v) = each %$nodelist) {
 325                 next if $k eq $name; # allows re-adding a node if force is set
 326                 if ($v->{ring0_addr} eq $addr || ($v->{ring1_addr} && $v->{ring1_addr} eq $addr)) {
 327                     die "corosync: address '$addr' already defined by node '$k'\n";
 328                 }
 329             }
 330         };
 331
 332         &$check_duplicate_addr($param->{ring0_addr});
 333         &$check_duplicate_addr($param->{ring1_addr});
 334
 335         $param->{ring0_addr} = $name if !$param->{ring0_addr};
 336
 337         die "corosync: using 'ring1_addr' parameter needs a configured ring 1 interface!\n"
 338             if $param->{ring1_addr} && !defined($totem_cfg->{interface}->{1});
 339
 340         die "corosync: ring 1 interface configured but 'ring1_addr' parameter not defined!\n"
 341             if defined($totem_cfg->{interface}->{1}) && !defined($param->{ring1_addr});
 342
 343         if (defined(my $res = $nodelist->{$name})) {
 344             $param->{nodeid} = $res->{nodeid} if !$param->{nodeid};
 345             $param->{votes} = $res->{quorum_votes} if !defined($param->{votes});
 346
 347             if ($res->{quorum_votes} == $param->{votes} &&
 348                 $res->{nodeid} == $param->{nodeid}) {
 349                 print "node $name already defined\n";
 350                 if ($param->{force}) {
 351                     exit (0);
 352                 } else {
 353                     exit (-1);
 354                 }
 355             } else {
 356                 die "can't add existing node\n";
 357             }
 358         } elsif (!$param->{nodeid}) {
 359             my $nodeid = 1;
 360
 361             while(1) {
 362                 my $found = 0;
 363                 foreach my $v (values %$nodelist) {
 364                     if ($v->{nodeid} eq $nodeid) {
 365                         $found = 1;
 366                         $nodeid++;
 367                         last;
 368                     }
 369                 }
 370                 last if !$found;
 371             };
 372
 373             $param->{nodeid} = $nodeid;
 374         }
 375
 376         $param->{votes} = 1 if !defined($param->{votes});
 377
 378         PVE::Cluster::gen_local_dirs($name);
 379
 380         eval {  PVE::Cluster::ssh_merge_keys(); };
 381         warn $@ if $@;
 382
 383         $nodelist->{$name} = {
 384             ring0_addr => $param->{ring0_addr},
 385             nodeid => $param->{nodeid},
 386             name => $name,
 387         };
 388         $nodelist->{$name}->{ring1_addr} = $param->{ring1_addr} if $param->{ring1_addr};
 389         $nodelist->{$name}->{quorum_votes} = $param->{votes} if $param->{votes};
 390
 391         PVE::Cluster::corosync_update_nodelist($conf, $nodelist);
 392
 393         exit (0);
 394     }});
 395
 396
 397 __PACKAGE__->register_method ({
 398     name => 'delnode',
 399     path => 'delnode',
 400     method => 'PUT',
 401     description => "Removes a node to the cluster configuration.",
 402     parameters => {
 403         additionalProperties => 0,
 404         properties => {
 405             node => {
 406                 type => 'string',
 407                 description => "Hostname or IP of the corosync ring0 address of this node.",
 408             },
 409         },
 410     },
 411     returns => { type => 'null' },
 412
 413     code => sub {
 414         my ($param) = @_;
 415
 416         PVE::Cluster::check_cfs_quorum();
 417
 418         my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
 419
 420         my $nodelist = PVE::Cluster::corosync_nodelist($conf);
 421
 422         my $node;
 423         my $nodeid;
 424
 425         foreach my $tmp_node (keys %$nodelist) {
 426             my $d = $nodelist->{$tmp_node};
 427             my $ring0_addr = $d->{ring0_addr};
 428             my $ring1_addr = $d->{ring1_addr};
 429             if (($tmp_node eq $param->{node}) ||
 430                 (defined($ring0_addr) && ($ring0_addr eq $param->{node})) ||
 431                 (defined($ring1_addr) && ($ring1_addr eq $param->{node}))) {
 432                 $node = $tmp_node;
 433                 $nodeid = $d->{nodeid};
 434                 last;
 435             }
 436         }
 437
 438         die "Node/IP: $param->{node} is not a known host of the cluster.\n"
 439                 if !defined($node);
 440
 441         delete $nodelist->{$node};
 442
 443         PVE::Cluster::corosync_update_nodelist($conf, $nodelist);
 444
 445         PVE::Tools::run_command(['corosync-cfgtool','-k', $nodeid])
 446             if defined($nodeid);
 447
 448         return undef;
 449     }});
 450
 451 __PACKAGE__->register_method ({
 452     name => 'add',
 453     path => 'add',
 454     method => 'PUT',
 455     description => "Adds the current node to an existing cluster.",
 456     parameters => {
 457         additionalProperties => 0,
 458         properties => {
 459             hostname => {
 460                 type => 'string',
 461                 description => "Hostname (or IP) of an existing cluster member."
 462             },
 463             nodeid => {
 464                 type => 'integer',
 465                 description => "Node id for this node.",
 466                 minimum => 1,
 467                 optional => 1,
 468             },
 469             votes => {
 470                 type => 'integer',
 471                 description => "Number of votes for this node",
 472                 minimum => 0,
 473                 optional => 1,
 474             },
 475             force => {
 476                 type => 'boolean',
 477                 description => "Do not throw error if node already exists.",
 478                 optional => 1,
 479             },
 480             ring0_addr => {
 481                 type => 'string', format => 'address',
 482                 description => "Hostname (or IP) of the corosync ring0 address of this node.".
 483                     " Defaults to nodes hostname.",
 484                 optional => 1,
 485             },
 486             ring1_addr => {
 487                 type => 'string', format => 'address',
 488                 description => "Hostname (or IP) of the corosync ring1 address, this".
 489                     " needs an valid configured ring 1 interface in the cluster.",
 490                 optional => 1,
 491             },
 492         },
 493     },
 494     returns => { type => 'null' },
 495
 496     code => sub {
 497         my ($param) = @_;
 498
 499         my $nodename = PVE::INotify::nodename();
 500
 501         PVE::Cluster::setup_sshd_config(1);
 502         PVE::Cluster::setup_rootsshconfig();
 503         PVE::Cluster::setup_ssh_keys();
 504
 505         my $host = $param->{hostname};
 506
 507         my ($errors, $warnings) = ('', '');
 508
 509         my $error = sub {
 510             my ($msg, $suppress) = @_;
 511
 512             if ($suppress) {
 513                 $warnings .= "* $msg\n";
 514             } else {
 515                 $errors .= "* $msg\n";
 516             }
 517         };
 518
 519         if (!$param->{force}) {
 520
 521             if (-f $authfile) {
 522                 &$error("authentication key '$authfile' already exists", $param->{force});
 523             }
 524
 525             if (-f $clusterconf)  {
 526                 &$error("cluster config '$clusterconf' already exists", $param->{force});
 527             }
 528
 529             my $vmlist = PVE::Cluster::get_vmlist();
 530             if ($vmlist && $vmlist->{ids} && scalar(keys %{$vmlist->{ids}})) {
 531                 &$error("this host already contains virtual guests", $param->{force});
 532             }
 533
 534             if (system("corosync-quorumtool -l >/dev/null 2>&1") == 0) {
 535                 &$error("corosync is already running, is this node already in a cluster?!", $param->{force});
 536             }
 537         }
 538
 539         warn "warning, ignore the following errors:\n$warnings" if $warnings;
 540         die "detected the following error(s):\n$errors" if $errors;
 541
 542         # make sure known_hosts is on local filesystem
 543         PVE::Cluster::ssh_unmerge_known_hosts();
 544
 545         my $cmd = ['ssh-copy-id', '-i', '/root/.ssh/id_rsa', "root\@$host"];
 546         PVE::Tools::run_command($cmd, 'outfunc' => sub {}, 'errfunc' => sub {},
 547                                 'errmsg' => "unable to copy ssh ID");
 548
 549         $cmd = ['ssh', $host, '-o', 'BatchMode=yes',
 550                 'pvecm', 'addnode', $nodename, '--force', 1];
 551
 552         push @$cmd, '--nodeid', $param->{nodeid} if $param->{nodeid};
 553
 554         push @$cmd, '--votes', $param->{votes} if defined($param->{votes});
 555
 556         push @$cmd, '--ring0_addr', $param->{ring0_addr} if defined($param->{ring0_addr});
 557
 558         push @$cmd, '--ring1_addr', $param->{ring1_addr} if defined($param->{ring1_addr});
 559
 560         if (system (@$cmd) != 0) {
 561             my $cmdtxt = join (' ', @$cmd);
 562             die "unable to add node: command failed ($cmdtxt)\n";
 563         }
 564
 565         my $tmpdir = "$libdir/.pvecm_add.tmp.$$";
 566         mkdir $tmpdir;
 567
 568         eval {
 569             print "copy corosync auth key\n";
 570             $cmd = ['rsync', '--rsh=ssh -l root -o BatchMode=yes', '-lpgoq',
 571                     "[$host]:$authfile $clusterconf", $tmpdir];
 572
 573             system(@$cmd) == 0 || die "can't rsync data from host '$host'\n";
 574
 575             mkdir "/etc/corosync";
 576             my $confbase = basename($clusterconf);
 577
 578             $cmd = "cp '$tmpdir/$confbase' '/etc/corosync/$confbase'";
 579             system($cmd) == 0 || die "can't copy cluster configuration\n";
 580
 581             my $keybase = basename($authfile);
 582             system ("cp '$tmpdir/$keybase' '$authfile'") == 0 ||
 583                 die "can't copy '$tmpdir/$keybase' to '$authfile'\n";
 584
 585             print "stopping pve-cluster service\n";
 586
 587             system("umount $basedir -f >/dev/null 2>&1");
 588             system("systemctl stop pve-cluster") == 0 ||
 589                 die "can't stop pve-cluster service\n";
 590
 591             backup_database();
 592
 593             unlink $dbfile;
 594
 595             system("systemctl start pve-cluster") == 0 ||
 596                 die "starting pve-cluster failed\n";
 597
 598             system("systemctl start corosync");
 599
 600             # wait for quorum
 601             my $printqmsg = 1;
 602             while (!PVE::Cluster::check_cfs_quorum(1)) {
 603                 if ($printqmsg) {
 604                     print "waiting for quorum...";
 605                     STDOUT->flush();
 606                     $printqmsg = 0;
 607                 }
 608                 sleep(1);
 609             }
 610             print "OK\n" if !$printqmsg;
 611
 612             my $local_ip_address = PVE::Cluster::remote_node_ip($nodename);
 613
 614             print "generating node certificates\n";
 615             PVE::Cluster::gen_pve_node_files($nodename, $local_ip_address);
 616
 617             print "merge known_hosts file\n";
 618             PVE::Cluster::ssh_merge_known_hosts($nodename, $local_ip_address, 1);
 619
 620             print "restart services\n";
 621             # restart pvedaemon (changed certs)
 622             system("systemctl restart pvedaemon");
 623             # restart pveproxy (changed certs)
 624             system("systemctl restart pveproxy");
 625
 626             print "successfully added node '$nodename' to cluster.\n";
 627         };
 628         my $err = $@;
 629
 630         rmtree $tmpdir;
 631
 632         die $err if $err;
 633
 634         return undef;
 635     }});
 636
 637 __PACKAGE__->register_method ({
 638     name => 'status',
 639     path => 'status',
 640     method => 'GET',
 641     description => "Displays the local view of the cluster status.",
 642     parameters => {
 643         additionalProperties => 0,
 644         properties => {},
 645     },
 646     returns => { type => 'null' },
 647
 648     code => sub {
 649         my ($param) = @_;
 650
 651         PVE::Cluster::check_corosync_conf_exists();
 652
 653         my $cmd = ['corosync-quorumtool', '-siH'];
 654
 655         exec (@$cmd);
 656
 657         exit (-1); # should not be reached
 658     }});
 659
 660 __PACKAGE__->register_method ({
 661     name => 'nodes',
 662     path => 'nodes',
 663     method => 'GET',
 664     description => "Displays the local view of the cluster nodes.",
 665     parameters => {
 666         additionalProperties => 0,
 667         properties => {},
 668     },
 669     returns => { type => 'null' },
 670
 671     code => sub {
 672         my ($param) = @_;
 673
 674         PVE::Cluster::check_corosync_conf_exists();
 675
 676         my $cmd = ['corosync-quorumtool', '-l'];
 677
 678         exec (@$cmd);
 679
 680         exit (-1); # should not be reached
 681     }});
 682
 683 __PACKAGE__->register_method ({
 684     name => 'expected',
 685     path => 'expected',
 686     method => 'PUT',
 687     description => "Tells corosync a new value of expected votes.",
 688     parameters => {
 689         additionalProperties => 0,
 690         properties => {
 691             expected => {
 692                 type => 'integer',
 693                 description => "Expected votes",
 694                 minimum => 1,
 695             },
 696         },
 697     },
 698     returns => { type => 'null' },
 699
 700     code => sub {
 701         my ($param) = @_;
 702
 703         PVE::Cluster::check_corosync_conf_exists();
 704
 705         my $cmd = ['corosync-quorumtool', '-e', $param->{expected}];
 706
 707         exec (@$cmd);
 708
 709         exit (-1); # should not be reached
 710
 711     }});
 712
 713 __PACKAGE__->register_method ({
 714     name => 'updatecerts',
 715     path => 'updatecerts',
 716     method => 'PUT',
 717     description => "Update node certificates (and generate all needed files/directories).",
 718     parameters => {
 719         additionalProperties => 0,
 720         properties => {
 721             force => {
 722                 description => "Force generation of new SSL certifate.",
 723                 type => 'boolean',
 724                 optional => 1,
 725             },
 726             silent => {
 727                 description => "Ignore errors (i.e. when cluster has no quorum).",
 728                 type => 'boolean',
 729                 optional => 1,
 730             },
 731         },
 732     },
 733     returns => { type => 'null' },
 734     code => sub {
 735         my ($param) = @_;
 736
 737         PVE::Cluster::setup_sshd_config(0);
 738         PVE::Cluster::setup_rootsshconfig();
 739
 740         PVE::Cluster::gen_pve_vzdump_symlink();
 741
 742         if (!PVE::Cluster::check_cfs_quorum(1)) {
 743             return undef if $param->{silent};
 744             die "no quorum - unable to update files\n";
 745         }
 746
 747         PVE::Cluster::setup_ssh_keys();
 748
 749         my $nodename = PVE::INotify::nodename();
 750
 751         my $local_ip_address = PVE::Cluster::remote_node_ip($nodename);
 752
 753         PVE::Cluster::gen_pve_node_files($nodename, $local_ip_address, $param->{force});
 754         PVE::Cluster::ssh_merge_keys();
 755         PVE::Cluster::ssh_merge_known_hosts($nodename, $local_ip_address);
 756         PVE::Cluster::gen_pve_vzdump_files();
 757
 758         return undef;
 759     }});
 760
 761 __PACKAGE__->register_method ({
 762     name => 'mtunnel',
 763     path => 'mtunnel',
 764     method => 'POST',
 765     description => "Used by VM/CT migration - do not use manually.",
 766     parameters => {
 767         additionalProperties => 0,
 768         properties => {
 769             get_migration_ip => {
 770                 type => 'boolean',
 771                 default => 0,
 772                 description => 'return the migration IP, if configured',
 773                 optional => 1,
 774             },
 775             migration_network => {
 776                 type => 'string',
 777                 format => 'CIDR',
 778                 description => 'the migration network used to detect the local migration IP',
 779                 optional => 1,
 780             },
 781         },
 782     },
 783     returns => { type => 'null'},
 784     code => sub {
 785         my ($param) = @_;
 786
 787         if (!PVE::Cluster::check_cfs_quorum(1)) {
 788             print "no quorum\n";
 789             return undef;
 790         }
 791
 792         if ($param->{get_migration_ip}) {
 793             my $network = $param->{migration_network};
 794             if (my $ip = PVE::Cluster::get_local_migration_ip($network)) {
 795                 print "ip: '$ip'\n";
 796             } else {
 797                 print "no ip\n";
 798             }
 799             # do not keep tunnel open when asked for migration ip
 800             return undef;
 801         }
 802
 803         print "tunnel online\n";
 804         *STDOUT->flush();
 805
 806         while (my $line = <>) {
 807             chomp $line;
 808             last if $line =~ m/^quit$/;
 809         }
 810
 811         return undef;
 812     }});
 813
 814
 815 our $cmddef = {
 816     keygen => [ __PACKAGE__, 'keygen', ['filename']],
 817     create => [ __PACKAGE__, 'create', ['clustername']],
 818     add => [ __PACKAGE__, 'add', ['hostname']],
 819     addnode => [ __PACKAGE__, 'addnode', ['node']],
 820     delnode => [ __PACKAGE__, 'delnode', ['node']],
 821     status => [ __PACKAGE__, 'status' ],
 822     nodes => [ __PACKAGE__, 'nodes' ],
 823     expected => [ __PACKAGE__, 'expected', ['expected']],
 824     updatecerts => [ __PACKAGE__, 'updatecerts', []],
 825     mtunnel => [ __PACKAGE__, 'mtunnel', []],
 826 };
 827
 828 1;