[pve-cluster.git] / data / PVE / API2 / ClusterConfig.pm

package PVE::API2::ClusterConfig;

use strict;
use warnings;

use PVE::Tools;
use PVE::SafeSyslog;
use PVE::RESTHandler;
use PVE::RPCEnvironment;
use PVE::JSONSchema qw(get_standard_option);
use PVE::Cluster;
use PVE::APIClient::LWP;
use PVE::Corosync;

use base qw(PVE::RESTHandler);

my $clusterconf = "/etc/pve/corosync.conf";
my $authfile = "/etc/corosync/authkey";
my $local_cluster_lock = "/var/lock/pvecm.lock";

my $ring0_desc = {
    type => 'string', format => 'address',
    description => "Hostname (or IP) of the corosync ring0 address of this node.",
    default => "Hostname of the node",
    optional => 1,
};
PVE::JSONSchema::register_standard_option("corosync-ring0-addr", $ring0_desc);

my $ring1_desc = {
    type => 'string', format => 'address',
    description => "Hostname (or IP) of the corosync ring1 address of this node.".
	" Requires a valid configured ring 1 (bindnet1_addr) in the cluster.",
    optional => 1,
};
PVE::JSONSchema::register_standard_option("corosync-ring1-addr", $ring1_desc);

my $nodeid_desc = {
    type => 'integer',
    description => "Node id for this node.",
    minimum => 1,
    optional => 1,
};
PVE::JSONSchema::register_standard_option("corosync-nodeid", $nodeid_desc);

__PACKAGE__->register_method({
    name => 'index',
    path => '',
    method => 'GET',
    description => "Directory index.",
    permissions => {
	check => ['perm', '/', [ 'Sys.Audit' ]],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => "object",
	    properties => {},
	},
	links => [ { rel => 'child', href => "{name}" } ],
    },
    code => sub {
	my ($param) = @_;

	my $result = [
	    { name => 'nodes' },
	    { name => 'totem' },
	    { name => 'join' },
	];

	return $result;
    }});

__PACKAGE__->register_method ({
    name => 'create',
    path => '',
    method => 'POST',
    protected => 1,
    description => "Generate new cluster configuration.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    clustername => {
		description => "The name of the cluster.",
		type => 'string', format => 'pve-node',
		maxLength => 15,
	    },
	    nodeid => get_standard_option('corosync-nodeid'),
	    votes => {
		type => 'integer',
		description => "Number of votes for this node.",
		minimum => 1,
		optional => 1,
	    },
	    bindnet0_addr => {
		type => 'string', format => 'ip',
		description => "This specifies the network address the corosync ring 0".
		    " executive should bind to and defaults to the local IP address of the node.",
		optional => 1,
	    },
	    ring0_addr => get_standard_option('corosync-ring0-addr'),
	    bindnet1_addr => {
		type => 'string', format => 'ip',
		description => "This specifies the network address the corosync ring 1".
		    " executive should bind to and is optional.",
		optional => 1,
	    },
	    ring1_addr => get_standard_option('corosync-ring1-addr'),
	},
    },
    returns => { type => 'string' },
    code => sub {
	my ($param) = @_;

	-f $clusterconf && die "cluster config '$clusterconf' already exists\n";

	my $rpcenv = PVE::RPCEnvironment::get();
	my $authuser = $rpcenv->get_user();

	my $code = sub {
	    STDOUT->autoflush();
	    PVE::Cluster::setup_sshd_config(1);
	    PVE::Cluster::setup_rootsshconfig();
	    PVE::Cluster::setup_ssh_keys();

	    PVE::Tools::run_command(['/usr/sbin/corosync-keygen', '-lk', $authfile])
		if !-f $authfile;
	    die "no authentication key available\n" if -f !$authfile;

	    my $nodename = PVE::INotify::nodename();

	    # get the corosync basis config for the new cluster
	    my $config = PVE::Corosync::create_conf($nodename, %$param);

	    print "Writing corosync config to /etc/pve/corosync.conf\n";
	    PVE::Corosync::atomic_write_conf($config);

	    my $local_ip_address = PVE::Cluster::remote_node_ip($nodename);
	    PVE::Cluster::ssh_merge_keys();
	    PVE::Cluster::gen_pve_node_files($nodename, $local_ip_address);
	    PVE::Cluster::ssh_merge_known_hosts($nodename, $local_ip_address, 1);

	    print "Restart corosync and cluster filesystem\n";
	    PVE::Tools::run_command('systemctl restart corosync pve-cluster');
	};

	my $worker = sub {
	    PVE::Tools::lock_file($local_cluster_lock, 10, $code);
	    die $@ if $@;
	};

	return $rpcenv->fork_worker('clustercreate', $param->{clustername},  $authuser, $worker);
}});

__PACKAGE__->register_method({
    name => 'nodes',
    path => 'nodes',
    method => 'GET',
    description => "Corosync node list.",
    permissions => {
	check => ['perm', '/', [ 'Sys.Audit' ]],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => "object",
	    properties => {
		node => { type => 'string' },
	    },
	},
	links => [ { rel => 'child', href => "{node}" } ],
    },
    code => sub {
	my ($param) = @_;


	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');
	my $nodelist = PVE::Corosync::nodelist($conf);

	return PVE::RESTHandler::hash_to_array($nodelist, 'node');
    }});

# lock method to ensure local and cluster wide atomicity
# if we're a single node cluster just lock locally, we have no other cluster
# node which we could contend with, else also acquire a cluster wide lock
my $config_change_lock = sub {
    my ($code) = @_;

    PVE::Tools::lock_file($local_cluster_lock, 10, sub {
	PVE::Cluster::cfs_update(1);
	my $members = PVE::Cluster::get_members();
	if (scalar(keys %$members) > 1) {
	    return PVE::Cluster::cfs_lock_file('corosync.conf', 10, $code);
	} else {
	    return $code->();
	}
    });
};

__PACKAGE__->register_method ({
    name => 'addnode',
    path => 'nodes/{node}',
    method => 'POST',
    protected => 1,
    description => "Adds a node to the cluster configuration.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    node => get_standard_option('pve-node'),
	    nodeid => get_standard_option('corosync-nodeid'),
	    votes => {
		type => 'integer',
		description => "Number of votes for this node",
		minimum => 0,
		optional => 1,
	    },
	    force => {
		type => 'boolean',
		description => "Do not throw error if node already exists.",
		optional => 1,
	    },
	    ring0_addr => get_standard_option('corosync-ring0-addr'),
	    ring1_addr => get_standard_option('corosync-ring1-addr'),
	},
    },
    returns => {
	type => "object",
	properties => {
	    corosync_authkey => {
		type => 'string',
	    },
	    corosync_conf => {
		type => 'string',
	    }
	},
    },
    code => sub {
	my ($param) = @_;

	PVE::Cluster::check_cfs_quorum();

	my $code = sub {
	    my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
	    my $nodelist = PVE::Corosync::nodelist($conf);
	    my $totem_cfg = PVE::Corosync::totem_config($conf);

	    my $name = $param->{node};

	    # ensure we do not reuse an address, that can crash the whole cluster!
	    my $check_duplicate_addr = sub {
		my $addr = shift;
		return if !defined($addr);

		while (my ($k, $v) = each %$nodelist) {
		    next if $k eq $name; # allows re-adding a node if force is set
			if ($v->{ring0_addr} eq $addr || ($v->{ring1_addr} && $v->{ring1_addr} eq $addr)) {
			    die "corosync: address '$addr' already defined by node '$k'\n";
			}
		}
	    };

	    &$check_duplicate_addr($param->{ring0_addr});
	    &$check_duplicate_addr($param->{ring1_addr});

	    $param->{ring0_addr} = $name if !$param->{ring0_addr};

	    die "corosync: using 'ring1_addr' parameter needs a configured ring 1 interface!\n"
		if $param->{ring1_addr} && !defined($totem_cfg->{interface}->{1});

	    die "corosync: ring 1 interface configured but 'ring1_addr' parameter not defined!\n"
		if defined($totem_cfg->{interface}->{1}) && !defined($param->{ring1_addr});

	    if (defined(my $res = $nodelist->{$name})) {
		$param->{nodeid} = $res->{nodeid} if !$param->{nodeid};
		$param->{votes} = $res->{quorum_votes} if !defined($param->{votes});

		if ($res->{quorum_votes} == $param->{votes} &&
		    $res->{nodeid} == $param->{nodeid} && $param->{force}) {
		    print "forcing overwrite of configured node '$name'\n";
		} else {
		    die "can't add existing node '$name'\n";
		}
	    } elsif (!$param->{nodeid}) {
		my $nodeid = 1;

		while(1) {
		    my $found = 0;
		    foreach my $v (values %$nodelist) {
			if ($v->{nodeid} eq $nodeid) {
			    $found = 1;
			    $nodeid++;
			    last;
			}
		    }
		    last if !$found;
		};

		$param->{nodeid} = $nodeid;
	    }

	    $param->{votes} = 1 if !defined($param->{votes});

	    PVE::Cluster::gen_local_dirs($name);

	    eval { PVE::Cluster::ssh_merge_keys(); };
	    warn $@ if $@;

	    $nodelist->{$name} = {
		ring0_addr => $param->{ring0_addr},
		nodeid => $param->{nodeid},
		name => $name,
	    };
	    $nodelist->{$name}->{ring1_addr} = $param->{ring1_addr} if $param->{ring1_addr};
	    $nodelist->{$name}->{quorum_votes} = $param->{votes} if $param->{votes};

	    PVE::Cluster::log_msg('notice', 'root@pam', "adding node $name to cluster");

	    PVE::Corosync::update_nodelist($conf, $nodelist);
	};

	$config_change_lock->($code);
	die $@ if $@;

	my $res = {
	    corosync_authkey => PVE::Tools::file_get_contents($authfile),
	    corosync_conf => PVE::Tools::file_get_contents($clusterconf),
	};

	return $res;
    }});


__PACKAGE__->register_method ({
    name => 'delnode',
    path => 'nodes/{node}',
    method => 'DELETE',
    protected => 1,
    description => "Removes a node from the cluster configuration.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    node => get_standard_option('pve-node'),
	},
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $local_node = PVE::INotify::nodename();
	die "Cannot delete myself from cluster!\n" if $param->{node} eq $local_node;

	PVE::Cluster::check_cfs_quorum();

	my $code = sub {
	    my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
	    my $nodelist = PVE::Corosync::nodelist($conf);

	    my $node;
	    my $nodeid;

	    foreach my $tmp_node (keys %$nodelist) {
		my $d = $nodelist->{$tmp_node};
		my $ring0_addr = $d->{ring0_addr};
		my $ring1_addr = $d->{ring1_addr};
		if (($tmp_node eq $param->{node}) ||
		    (defined($ring0_addr) && ($ring0_addr eq $param->{node})) ||
		    (defined($ring1_addr) && ($ring1_addr eq $param->{node}))) {
		    $node = $tmp_node;
		    $nodeid = $d->{nodeid};
		    last;
		}
	    }

	    die "Node/IP: $param->{node} is not a known host of the cluster.\n"
		if !defined($node);

	    PVE::Cluster::log_msg('notice', 'root@pam', "deleting node $node from cluster");

	    delete $nodelist->{$node};

	    PVE::Corosync::update_nodelist($conf, $nodelist);

	    PVE::Tools::run_command(['corosync-cfgtool','-k', $nodeid]) if defined($nodeid);
	};

	$config_change_lock->($code);
	die $@ if $@;

	return undef;
    }});

__PACKAGE__->register_method ({
    name => 'join_info',
    path => 'join',
    permissions => {
	check => ['perm', '/', [ 'Sys.Audit' ]],
    },
    method => 'GET',
    description => "Get information needed to join this cluster over the connected node.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    node => get_standard_option('pve-node', {
		description => "The node for which the joinee gets the nodeinfo. ",
		default => "current connected node",
		optional => 1,
	    }),
	},
    },
    returns => {
	type => 'object',
	additionalProperties => 0,
	properties => {
	    nodelist => {
		type => 'array',
		items => {
		    type => "object",
		    additionalProperties => 1,
		    properties => {
			name => get_standard_option('pve-node'),
			nodeid => get_standard_option('corosync-nodeid'),
			ring0_addr => get_standard_option('corosync-ring0-addr'),
			quorum_votes => { type => 'integer', minimum => 0 },
			pve_addr => { type => 'string', format => 'ip' },
			pve_fp => get_standard_option('fingerprint-sha256'),
		    },
		},
	    },
	    preferred_node => get_standard_option('pve-node'),
	    totem => { type => 'object' },
	    config_digest => { type => 'string' },
	},
    },
    code => sub {
	my ($param) = @_;

	my $nodename = $param->{node} // PVE::INotify::nodename();

	PVE::Cluster::cfs_update(1);
	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');

	die "node is not in a cluster, no join info available!\n"
	    if !($conf && $conf->{main});

	my $totem_cfg = $conf->{main}->{totem} // {};
	my $nodelist = $conf->{main}->{nodelist}->{node} // {};
	my $corosync_config_digest = $conf->{digest};

	die "unknown node '$nodename'\n" if ! $nodelist->{$nodename};

	foreach my $name (keys %$nodelist) {
	    my $node = $nodelist->{$name};
	    $node->{pve_fp} = PVE::Cluster::get_node_fingerprint($name);
	    $node->{pve_addr} = scalar(PVE::Cluster::remote_node_ip($name));
	}

	my $res = {
	    nodelist => [ values %$nodelist ],
	    preferred_node => $nodename,
	    totem => $totem_cfg,
	    config_digest => $corosync_config_digest,
	};

	return $res;
    }});

__PACKAGE__->register_method ({
    name => 'join',
    path => 'join',
    method => 'POST',
    protected => 1,
    description => "Joins this node into an existing cluster.",
    parameters => {
	additionalProperties => 0,
	properties => {
	    hostname => {
		type => 'string',
		description => "Hostname (or IP) of an existing cluster member."
	    },
	    nodeid => get_standard_option('corosync-nodeid'),
	    votes => {
		type => 'integer',
		description => "Number of votes for this node",
		minimum => 0,
		optional => 1,
	    },
	    force => {
		type => 'boolean',
		description => "Do not throw error if node already exists.",
		optional => 1,
	    },
	    ring0_addr => get_standard_option('corosync-ring0-addr', {
		default => "IP resolved by node's hostname",
	    }),
	    ring1_addr => get_standard_option('corosync-ring1-addr'),
	    fingerprint => get_standard_option('fingerprint-sha256'),
	    password => {
		description => "Superuser (root) password of peer node.",
		type => 'string',
		maxLength => 128,
	    },
	},
    },
    returns => { type => 'string' },
    code => sub {
	my ($param) = @_;

	my $rpcenv = PVE::RPCEnvironment::get();
	my $authuser = $rpcenv->get_user();

	my $worker = sub {
	    STDOUT->autoflush();
	    PVE::Tools::lock_file($local_cluster_lock, 10, \&PVE::Cluster::join, $param);
	    die $@ if $@;
	};

	return $rpcenv->fork_worker('clusterjoin', undef,  $authuser, $worker);
    }});


__PACKAGE__->register_method({
    name => 'totem',
    path => 'totem',
    method => 'GET',
    description => "Get corosync totem protocol settings.",
    permissions => {
	check => ['perm', '/', [ 'Sys.Audit' ]],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => "object",
	properties => {},
    },
    code => sub {
	my ($param) = @_;


	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');

	my $totem_cfg = $conf->{main}->{totem};

	return $totem_cfg;
    }});

1;
Commit	Line	Data
963c06bb DM	1	package PVE::API2::ClusterConfig;
	2
	3	use strict;
	4	use warnings;
b6973a89	5
963c06bb DM	6	use PVE::Tools;
	7	use PVE::SafeSyslog;
	8	use PVE::RESTHandler;
	9	use PVE::RPCEnvironment;
	10	use PVE::JSONSchema qw(get_standard_option);
	11	use PVE::Cluster;
6ed49eb1	12	use PVE::APIClient::LWP;
b6973a89	13	use PVE::Corosync;
963c06bb DM	14
	15	use base qw(PVE::RESTHandler);
	16
74e09a93 TL	17	my $clusterconf = "/etc/pve/corosync.conf";
74e09a93 TL	18	my $authfile = "/etc/corosync/authkey";
b184a69d	19	my $local_cluster_lock = "/var/lock/pvecm.lock";
74e09a93	20
10c6810e TL	21	my $ring0_desc = {
	22	type => 'string', format => 'address',
	23	description => "Hostname (or IP) of the corosync ring0 address of this node.",
	24	default => "Hostname of the node",
	25	optional => 1,
	26	};
	27	PVE::JSONSchema::register_standard_option("corosync-ring0-addr", $ring0_desc);
	28
	29	my $ring1_desc = {
	30	type => 'string', format => 'address',
	31	description => "Hostname (or IP) of the corosync ring1 address of this node.".
	32	" Requires a valid configured ring 1 (bindnet1_addr) in the cluster.",
	33	optional => 1,
	34	};
	35	PVE::JSONSchema::register_standard_option("corosync-ring1-addr", $ring1_desc);
	36
	37	my $nodeid_desc = {
	38	type => 'integer',
	39	description => "Node id for this node.",
	40	minimum => 1,
	41	optional => 1,
	42	};
	43	PVE::JSONSchema::register_standard_option("corosync-nodeid", $nodeid_desc);
	44
963c06bb DM	45	__PACKAGE__->register_method({
	46	name => 'index',
	47	path => '',
	48	method => 'GET',
	49	description => "Directory index.",
fb7c665a EK	50	permissions => {
	51	check => ['perm', '/', [ 'Sys.Audit' ]],
	52	},
963c06bb DM	53	parameters => {
	54	additionalProperties => 0,
	55	properties => {},
	56	},
	57	returns => {
	58	type => 'array',
	59	items => {
	60	type => "object",
	61	properties => {},
	62	},
	63	links => [ { rel => 'child', href => "{name}" } ],
	64	},
	65	code => sub {
	66	my ($param) = @_;
	67
	68	my $result = [
	69	{ name => 'nodes' },
	70	{ name => 'totem' },
6ed49eb1 TL	71	{ name => 'join' },
6ed49eb1 TL	72	];
963c06bb DM	73
	74	return $result;
	75	}});
	76
74e09a93 TL	77	__PACKAGE__->register_method ({
	78	name => 'create',
	79	path => '',
	80	method => 'POST',
	81	protected => 1,
	82	description => "Generate new cluster configuration.",
	83	parameters => {
	84	additionalProperties => 0,
	85	properties => {
	86	clustername => {
	87	description => "The name of the cluster.",
	88	type => 'string', format => 'pve-node',
	89	maxLength => 15,
	90	},
10c6810e	91	nodeid => get_standard_option('corosync-nodeid'),
74e09a93 TL	92	votes => {
	93	type => 'integer',
	94	description => "Number of votes for this node.",
	95	minimum => 1,
	96	optional => 1,
	97	},
	98	bindnet0_addr => {
	99	type => 'string', format => 'ip',
	100	description => "This specifies the network address the corosync ring 0".
	101	" executive should bind to and defaults to the local IP address of the node.",
	102	optional => 1,
	103	},
10c6810e	104	ring0_addr => get_standard_option('corosync-ring0-addr'),
74e09a93 TL	105	bindnet1_addr => {
	106	type => 'string', format => 'ip',
	107	description => "This specifies the network address the corosync ring 1".
	108	" executive should bind to and is optional.",
	109	optional => 1,
	110	},
10c6810e	111	ring1_addr => get_standard_option('corosync-ring1-addr'),
74e09a93 TL	112	},
74e09a93 TL	113	},
333a9bc8	114	returns => { type => 'string' },
74e09a93 TL	115	code => sub {
	116	my ($param) = @_;
	117
	118	-f $clusterconf && die "cluster config '$clusterconf' already exists\n";
	119
333a9bc8 TL	120	my $rpcenv = PVE::RPCEnvironment::get();
	121	my $authuser = $rpcenv->get_user();
	122
b184a69d	123	my $code = sub {
17a4445f	124	STDOUT->autoflush();
333a9bc8 TL	125	PVE::Cluster::setup_sshd_config(1);
	126	PVE::Cluster::setup_rootsshconfig();
	127	PVE::Cluster::setup_ssh_keys();
74e09a93	128
333a9bc8 TL	129	PVE::Tools::run_command(['/usr/sbin/corosync-keygen', '-lk', $authfile])
	130	if !-f $authfile;
	131	die "no authentication key available\n" if -f !$authfile;
74e09a93	132
333a9bc8	133	my $nodename = PVE::INotify::nodename();
74e09a93	134
333a9bc8 TL	135	# get the corosync basis config for the new cluster
333a9bc8 TL	136	my $config = PVE::Corosync::create_conf($nodename, %$param);
74e09a93	137
333a9bc8 TL	138	print "Writing corosync config to /etc/pve/corosync.conf\n";
333a9bc8 TL	139	PVE::Corosync::atomic_write_conf($config);
74e09a93	140
333a9bc8 TL	141	my $local_ip_address = PVE::Cluster::remote_node_ip($nodename);
	142	PVE::Cluster::ssh_merge_keys();
	143	PVE::Cluster::gen_pve_node_files($nodename, $local_ip_address);
	144	PVE::Cluster::ssh_merge_known_hosts($nodename, $local_ip_address, 1);
74e09a93	145
333a9bc8 TL	146	print "Restart corosync and cluster filesystem\n";
	147	PVE::Tools::run_command('systemctl restart corosync pve-cluster');
	148	};
74e09a93	149
b184a69d TL	150	my $worker = sub {
	151	PVE::Tools::lock_file($local_cluster_lock, 10, $code);
	152	die $@ if $@;
	153	};
	154
65ee8001	155	return $rpcenv->fork_worker('clustercreate', $param->{clustername}, $authuser, $worker);
74e09a93 TL	156	}});
74e09a93 TL	157
963c06bb DM	158	__PACKAGE__->register_method({
	159	name => 'nodes',
	160	path => 'nodes',
	161	method => 'GET',
	162	description => "Corosync node list.",
fb7c665a EK	163	permissions => {
	164	check => ['perm', '/', [ 'Sys.Audit' ]],
	165	},
963c06bb DM	166	parameters => {
	167	additionalProperties => 0,
	168	properties => {},
	169	},
	170	returns => {
	171	type => 'array',
	172	items => {
	173	type => "object",
	174	properties => {
	175	node => { type => 'string' },
	176	},
	177	},
	178	links => [ { rel => 'child', href => "{node}" } ],
	179	},
	180	code => sub {
	181	my ($param) = @_;
	182
	183
	184	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');
b6973a89	185	my $nodelist = PVE::Corosync::nodelist($conf);
963c06bb DM	186
	187	return PVE::RESTHandler::hash_to_array($nodelist, 'node');
	188	}});
	189
1d26c202 TL	190	# lock method to ensure local and cluster wide atomicity
	191	# if we're a single node cluster just lock locally, we have no other cluster
	192	# node which we could contend with, else also acquire a cluster wide lock
	193	my $config_change_lock = sub {
	194	my ($code) = @_;
	195
b184a69d	196	PVE::Tools::lock_file($local_cluster_lock, 10, sub {
1d26c202 TL	197	PVE::Cluster::cfs_update(1);
	198	my $members = PVE::Cluster::get_members();
	199	if (scalar(keys %$members) > 1) {
	200	return PVE::Cluster::cfs_lock_file('corosync.conf', 10, $code);
	201	} else {
	202	return $code->();
	203	}
	204	});
	205	};
	206
1d26c202 TL	207	__PACKAGE__->register_method ({
	208	name => 'addnode',
	209	path => 'nodes/{node}',
	210	method => 'POST',
	211	protected => 1,
	212	description => "Adds a node to the cluster configuration.",
	213	parameters => {
	214	additionalProperties => 0,
	215	properties => {
	216	node => get_standard_option('pve-node'),
10c6810e	217	nodeid => get_standard_option('corosync-nodeid'),
1d26c202 TL	218	votes => {
	219	type => 'integer',
	220	description => "Number of votes for this node",
	221	minimum => 0,
	222	optional => 1,
	223	},
	224	force => {
	225	type => 'boolean',
	226	description => "Do not throw error if node already exists.",
	227	optional => 1,
	228	},
10c6810e TL	229	ring0_addr => get_standard_option('corosync-ring0-addr'),
10c6810e TL	230	ring1_addr => get_standard_option('corosync-ring1-addr'),
1d26c202 TL	231	},
1d26c202 TL	232	},
331d957b TL	233	returns => {
	234	type => "object",
	235	properties => {
	236	corosync_authkey => {
	237	type => 'string',
	238	},
	239	corosync_conf => {
	240	type => 'string',
	241	}
	242	},
	243	},
1d26c202 TL	244	code => sub {
	245	my ($param) = @_;
	246
	247	PVE::Cluster::check_cfs_quorum();
	248
	249	my $code = sub {
	250	my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
	251	my $nodelist = PVE::Corosync::nodelist($conf);
	252	my $totem_cfg = PVE::Corosync::totem_config($conf);
	253
	254	my $name = $param->{node};
	255
	256	# ensure we do not reuse an address, that can crash the whole cluster!
	257	my $check_duplicate_addr = sub {
	258	my $addr = shift;
	259	return if !defined($addr);
	260
	261	while (my ($k, $v) = each %$nodelist) {
	262	next if $k eq $name; # allows re-adding a node if force is set
	263	if ($v->{ring0_addr} eq $addr \|\| ($v->{ring1_addr} && $v->{ring1_addr} eq $addr)) {
	264	die "corosync: address '$addr' already defined by node '$k'\n";
	265	}
	266	}
	267	};
	268
	269	&$check_duplicate_addr($param->{ring0_addr});
	270	&$check_duplicate_addr($param->{ring1_addr});
	271
	272	$param->{ring0_addr} = $name if !$param->{ring0_addr};
	273
	274	die "corosync: using 'ring1_addr' parameter needs a configured ring 1 interface!\n"
	275	if $param->{ring1_addr} && !defined($totem_cfg->{interface}->{1});
	276
	277	die "corosync: ring 1 interface configured but 'ring1_addr' parameter not defined!\n"
	278	if defined($totem_cfg->{interface}->{1}) && !defined($param->{ring1_addr});
	279
	280	if (defined(my $res = $nodelist->{$name})) {
	281	$param->{nodeid} = $res->{nodeid} if !$param->{nodeid};
	282	$param->{votes} = $res->{quorum_votes} if !defined($param->{votes});
	283
	284	if ($res->{quorum_votes} == $param->{votes} &&
	285	$res->{nodeid} == $param->{nodeid} && $param->{force}) {
	286	print "forcing overwrite of configured node '$name'\n";
	287	} else {
	288	die "can't add existing node '$name'\n";
	289	}
	290	} elsif (!$param->{nodeid}) {
	291	my $nodeid = 1;
	292
	293	while(1) {
	294	my $found = 0;
	295	foreach my $v (values %$nodelist) {
	296	if ($v->{nodeid} eq $nodeid) {
	297	$found = 1;
	298	$nodeid++;
	299	last;
	300	}
	301	}
	302	last if !$found;
	303	};
	304
	305	$param->{nodeid} = $nodeid;
	306	}
	307
308	$param->{votes} = 1 if !defined($param->{votes});
309
310	PVE::Cluster::gen_local_dirs($name);
311
312	eval { PVE::Cluster::ssh_merge_keys(); };
313	warn $@ if $@;
314
315	$nodelist->{$name} = {
316	ring0_addr => $param->{ring0_addr},
317	nodeid => $param->{nodeid},
318	name => $name,
319	};
320	$nodelist->{$name}->{ring1_addr} = $param->{ring1_addr} if $param->{ring1_addr};
321	$nodelist->{$name}->{quorum_votes} = $param->{votes} if $param->{votes};
322
855671ec TL	323	PVE::Cluster::log_msg('notice', 'root@pam', "adding node $name to cluster");
855671ec TL	324
1d26c202 TL	325	PVE::Corosync::update_nodelist($conf, $nodelist);
	326	};
	327
	328	$config_change_lock->($code);
	329	die $@ if $@;
	330
331d957b TL	331	my $res = {
	332	corosync_authkey => PVE::Tools::file_get_contents($authfile),
	333	corosync_conf => PVE::Tools::file_get_contents($clusterconf),
	334	};
	335
	336	return $res;
1d26c202 TL	337	}});
	338
	339
	340	__PACKAGE__->register_method ({
	341	name => 'delnode',
	342	path => 'nodes/{node}',
	343	method => 'DELETE',
	344	protected => 1,
	345	description => "Removes a node from the cluster configuration.",
	346	parameters => {
	347	additionalProperties => 0,
	348	properties => {
	349	node => get_standard_option('pve-node'),
	350	},
	351	},
	352	returns => { type => 'null' },
	353	code => sub {
	354	my ($param) = @_;
	355
	356	my $local_node = PVE::INotify::nodename();
	357	die "Cannot delete myself from cluster!\n" if $param->{node} eq $local_node;
	358
	359	PVE::Cluster::check_cfs_quorum();
	360
	361	my $code = sub {
	362	my $conf = PVE::Cluster::cfs_read_file("corosync.conf");
	363	my $nodelist = PVE::Corosync::nodelist($conf);
	364
	365	my $node;
	366	my $nodeid;
	367
	368	foreach my $tmp_node (keys %$nodelist) {
	369	my $d = $nodelist->{$tmp_node};
	370	my $ring0_addr = $d->{ring0_addr};
	371	my $ring1_addr = $d->{ring1_addr};
	372	if (($tmp_node eq $param->{node}) \|\|
	373	(defined($ring0_addr) && ($ring0_addr eq $param->{node})) \|\|
	374	(defined($ring1_addr) && ($ring1_addr eq $param->{node}))) {
	375	$node = $tmp_node;
	376	$nodeid = $d->{nodeid};
	377	last;
	378	}
	379	}
	380
	381	die "Node/IP: $param->{node} is not a known host of the cluster.\n"
	382	if !defined($node);
	383
855671ec TL	384	PVE::Cluster::log_msg('notice', 'root@pam', "deleting node $node from cluster");
855671ec TL	385
1d26c202 TL	386	delete $nodelist->{$node};
	387
	388	PVE::Corosync::update_nodelist($conf, $nodelist);
	389
	390	PVE::Tools::run_command(['corosync-cfgtool','-k', $nodeid]) if defined($nodeid);
	391	};
	392
	393	$config_change_lock->($code);
	394	die $@ if $@;
	395
	396	return undef;
	397	}});
	398
fca7797d TL	399	__PACKAGE__->register_method ({
	400	name => 'join_info',
	401	path => 'join',
be85d00b TL	402	permissions => {
	403	check => ['perm', '/', [ 'Sys.Audit' ]],
	404	},
fca7797d TL	405	method => 'GET',
	406	description => "Get information needed to join this cluster over the connected node.",
	407	parameters => {
	408	additionalProperties => 0,
	409	properties => {
	410	node => get_standard_option('pve-node', {
	411	description => "The node for which the joinee gets the nodeinfo. ",
	412	default => "current connected node",
	413	optional => 1,
	414	}),
	415	},
	416	},
	417	returns => {
	418	type => 'object',
	419	additionalProperties => 0,
	420	properties => {
	421	nodelist => {
	422	type => 'array',
	423	items => {
	424	type => "object",
	425	additionalProperties => 1,
	426	properties => {
	427	name => get_standard_option('pve-node'),
	428	nodeid => get_standard_option('corosync-nodeid'),
	429	ring0_addr => get_standard_option('corosync-ring0-addr'),
	430	quorum_votes => { type => 'integer', minimum => 0 },
	431	pve_addr => { type => 'string', format => 'ip' },
	432	pve_fp => get_standard_option('fingerprint-sha256'),
	433	},
	434	},
	435	},
	436	preferred_node => get_standard_option('pve-node'),
	437	totem => { type => 'object' },
	438	config_digest => { type => 'string' },
	439	},
	440	},
	441	code => sub {
	442	my ($param) = @_;
	443
	444	my $nodename = $param->{node} // PVE::INotify::nodename();
	445
	446	PVE::Cluster::cfs_update(1);
	447	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');
	448
	449	die "node is not in a cluster, no join info available!\n"
	450	if !($conf && $conf->{main});
	451
	452	my $totem_cfg = $conf->{main}->{totem} // {};
	453	my $nodelist = $conf->{main}->{nodelist}->{node} // {};
	454	my $corosync_config_digest = $conf->{digest};
	455
	456	die "unknown node '$nodename'\n" if ! $nodelist->{$nodename};
	457
	458	foreach my $name (keys %$nodelist) {
	459	my $node = $nodelist->{$name};
	460	$node->{pve_fp} = PVE::Cluster::get_node_fingerprint($name);
	461	$node->{pve_addr} = scalar(PVE::Cluster::remote_node_ip($name));
	462	}
	463
	464	my $res = {
	465	nodelist => [ values %$nodelist ],
	466	preferred_node => $nodename,
	467	totem => $totem_cfg,
	468	config_digest => $corosync_config_digest,
469	};
470
471	return $res;
472	}});
473
6ed49eb1 TL	474	__PACKAGE__->register_method ({
	475	name => 'join',
	476	path => 'join',
	477	method => 'POST',
	478	protected => 1,
	479	description => "Joins this node into an existing cluster.",
	480	parameters => {
	481	additionalProperties => 0,
	482	properties => {
	483	hostname => {
	484	type => 'string',
	485	description => "Hostname (or IP) of an existing cluster member."
	486	},
10c6810e	487	nodeid => get_standard_option('corosync-nodeid'),
6ed49eb1 TL	488	votes => {
	489	type => 'integer',
	490	description => "Number of votes for this node",
	491	minimum => 0,
	492	optional => 1,
	493	},
	494	force => {
	495	type => 'boolean',
	496	description => "Do not throw error if node already exists.",
	497	optional => 1,
	498	},
10c6810e	499	ring0_addr => get_standard_option('corosync-ring0-addr', {
072ba2e0	500	default => "IP resolved by node's hostname",
10c6810e TL	501	}),
10c6810e TL	502	ring1_addr => get_standard_option('corosync-ring1-addr'),
6ed49eb1 TL	503	fingerprint => get_standard_option('fingerprint-sha256'),
	504	password => {
	505	description => "Superuser (root) password of peer node.",
	506	type => 'string',
	507	maxLength => 128,
	508	},
	509	},
	510	},
	511	returns => { type => 'string' },
	512	code => sub {
	513	my ($param) = @_;
	514
	515	my $rpcenv = PVE::RPCEnvironment::get();
	516	my $authuser = $rpcenv->get_user();
	517
	518	my $worker = sub {
17a4445f	519	STDOUT->autoflush();
b184a69d TL	520	PVE::Tools::lock_file($local_cluster_lock, 10, \&PVE::Cluster::join, $param);
b184a69d TL	521	die $@ if $@;
6ed49eb1 TL	522	};
6ed49eb1 TL	523
8c4e30d3	524	return $rpcenv->fork_worker('clusterjoin', undef, $authuser, $worker);
6ed49eb1 TL	525	}});
	526
	527
963c06bb DM	528	__PACKAGE__->register_method({
	529	name => 'totem',
	530	path => 'totem',
	531	method => 'GET',
	532	description => "Get corosync totem protocol settings.",
fb7c665a EK	533	permissions => {
	534	check => ['perm', '/', [ 'Sys.Audit' ]],
	535	},
963c06bb DM	536	parameters => {
	537	additionalProperties => 0,
	538	properties => {},
	539	},
	540	returns => {
	541	type => "object",
	542	properties => {},
	543	},
	544	code => sub {
	545	my ($param) = @_;
	546
	547
	548	my $conf = PVE::Cluster::cfs_read_file('corosync.conf');
	549
496de919 TL	550	my $totem_cfg = $conf->{main}->{totem};
	551
	552	return $totem_cfg;
963c06bb DM	553	}});
	554
	555	1;