8 use Net
::IP
qw(ip_is_ipv6);
9 use Scalar
::Util
qw(weaken);
10 use Socket
qw(AF_INET AF_INET6 inet_ntop);
15 use PVE
::Tools
qw($IPV4RE $IPV6RE);
17 my $basedir = "/etc/pve";
19 my $conf_array_sections = {
24 my $corosync_link_format = {
27 type
=> 'string', format
=> 'address',
28 format_description
=> 'IP',
29 description
=> "Hostname (or IP) of this corosync link address.",
37 description
=> "The priority for the link when knet is used in 'passive' mode. Lower value means higher priority.",
40 my $corosync_link_desc = {
41 type
=> 'string', format
=> $corosync_link_format,
42 description
=> "Address and priority information of a single corosync link.",
45 PVE
::JSONSchema
::register_standard_option
("corosync-link", $corosync_link_desc);
47 sub parse_corosync_link
{
50 return undef if !defined($value);
52 return PVE
::JSONSchema
::parse_property_string
($corosync_link_format, $value);
55 # a very simply parser ...
57 my ($filename, $raw) = @_;
61 my $digest = Digest
::SHA
::sha1_hex
(defined($raw) ?
$raw : '');
69 my @tokens = split(/\s/, $raw);
71 my $conf = { 'main' => {} };
74 my $section = $conf->{main
};
76 while (defined(my $token = shift @tokens)) {
77 my $nexttok = $tokens[0];
79 if ($nexttok && ($nexttok eq '{')) {
80 shift @tokens; # skip '{'
82 if ($conf_array_sections->{$token}) {
83 $section->{$token} = [] if !defined($section->{$token});
84 push @{$section->{$token}}, $new_section;
85 } elsif (!defined($section->{$token})) {
86 $section->{$token} = $new_section;
88 die "section '$token' already exists and not marked as array!\n";
90 push @$stack, $section;
91 $section = $new_section;
96 $section = pop @$stack;
97 die "parse error - uncexpected '}'\n" if !$section;
102 die "missing ':' after key '$key'\n" if ! ($key =~ s/:$//);
104 die "parse error - no value for '$key'\n" if !defined($nexttok);
105 my $value = shift @tokens;
107 $section->{$key} = $value;
110 # make working with the config way easier
111 my ($totem, $nodelist) = $conf->{main
}->@{"totem", "nodelist"};
113 $nodelist->{node
} = {
115 $_->{name
} // $_->{ring0_addr
} => $_
116 } @{$nodelist->{node
}}
118 $totem->{interface
} = {
120 $_->{linknumber
} // $_->{ringnumber
} => $_
121 } @{$totem->{interface
}}
124 $conf->{digest
} = $digest;
130 my ($filename, $conf) = @_;
132 my $c = clone
($conf->{main
}) // die "no main section";
134 # retransform back for easier dumping
135 my $hash_to_array = sub {
137 return [ $hash->@{sort keys %$hash} ];
140 $c->{nodelist
}->{node
} = &$hash_to_array($c->{nodelist
}->{node
});
141 $c->{totem
}->{interface
} = &$hash_to_array($c->{totem
}->{interface
});
143 my $dump_section_weak;
144 $dump_section_weak = sub {
145 my ($section, $prefix) = @_;
149 foreach my $k (sort keys %$section) {
150 my $v = $section->{$k};
151 if (ref($v) eq 'HASH') {
152 $raw .= $prefix . "$k {\n";
153 $raw .= $dump_section_weak->($v, "$prefix ");
154 $raw .= $prefix . "}\n";
155 $raw .= "\n" if !$prefix; # add extra newline at 1st level only
156 } elsif (ref($v) eq 'ARRAY') {
157 foreach my $child (@$v) {
158 $raw .= $prefix . "$k {\n";
159 $raw .= $dump_section_weak->($child, "$prefix ");
160 $raw .= $prefix . "}\n";
163 die "got undefined value for key '$k'!\n" if !defined($v);
164 $raw .= $prefix . "$k: $v\n";
166 die "unexpected reference in config hash: $k => ". ref($v) ."\n";
172 my $dump_section = $dump_section_weak;
173 weaken
($dump_section_weak);
175 my $raw = $dump_section->($c, '');
180 # read only - use atomic_write_conf method to write
181 PVE
::Cluster
::cfs_register_file
('corosync.conf', \
&parse_conf
);
183 PVE
::Cluster
::cfs_register_file
('corosync.conf.new', \
&parse_conf
,
186 sub check_conf_exists
{
189 my $exists = -f
"$basedir/corosync.conf";
191 die "Error: Corosync config '$basedir/corosync.conf' does not exist - is this node part of a cluster?\n"
192 if !$noerr && !$exists;
197 sub update_nodelist
{
198 my ($conf, $nodelist) = @_;
200 $conf->{main
}->{nodelist
}->{node
} = $nodelist;
202 atomic_write_conf
($conf);
207 return clone
($conf->{main
}->{nodelist
}->{node
});
212 return clone
($conf->{main
}->{totem
});
215 # caller must hold corosync.conf cfs lock if used in read-modify-write cycle
216 sub atomic_write_conf
{
217 my ($conf, $no_increase_version) = @_;
219 if (!$no_increase_version) {
220 die "invalid corosync config: unable to read config version\n"
221 if !defined($conf->{main
}->{totem
}->{config_version
});
222 $conf->{main
}->{totem
}->{config_version
}++;
225 PVE
::Cluster
::cfs_write_file
("corosync.conf.new", $conf);
227 rename("/etc/pve/corosync.conf.new", "/etc/pve/corosync.conf")
228 || die "activating corosync.conf.new failed - $!\n";
231 # for creating a new cluster with the current node
232 # params are those from the API/CLI cluster create call
234 my ($nodename, %param) = @_;
236 my $clustername = $param{clustername
};
237 my $nodeid = $param{nodeid
} || 1;
238 my $votes = $param{votes
} || 1;
240 my $local_ip_address = PVE
::Cluster
::remote_node_ip
($nodename);
242 my $link0 = parse_corosync_link
($param{link0
});
243 $link0->{address
} //= $local_ip_address;
247 version
=> 2, # protocol version
249 cluster_name
=> $clustername,
251 ip_version
=> 'ipv4-6',
263 quorum_votes
=> $votes,
264 ring0_addr
=> $link0->{address
},
269 provider
=> 'corosync_votequorum',
276 my $totem = $conf->{totem
};
278 $totem->{interface
}->{0}->{knet_link_priority
} = $link0->{priority
}
279 if defined($link0->{priority
});
281 my $link1 = parse_corosync_link
($param{link1
});
282 if ($link1->{address
}) {
283 $conf->{totem
}->{interface
}->{1} = {
286 $totem->{link_mode
} = 'passive';
287 $totem->{interface
}->{1}->{knet_link_priority
} = $link1->{priority
}
288 if defined($link1->{priority
});
289 $conf->{nodelist
}->{node
}->{$nodename}->{ring1_addr
} = $link1->{address
};
292 return { main
=> $conf };
295 sub for_all_corosync_addresses
{
296 my ($corosync_conf, $ip_version, $func) = @_;
298 my $nodelist = nodelist
($corosync_conf);
299 return if !defined($nodelist);
301 # iterate sorted to make rules deterministic (for change detection)
302 foreach my $node_name (sort keys %$nodelist) {
303 my $node_config = $nodelist->{$node_name};
304 foreach my $node_key (sort keys %$node_config) {
305 if ($node_key =~ /^(ring|link)\d+_addr$/) {
306 my $node_address = $node_config->{$node_key};
308 my($ip, $version) = resolve_hostname_like_corosync
($node_address, $corosync_conf);
309 next if !defined($ip);
310 next if defined($version) && defined($ip_version) && $version != $ip_version;
312 $func->($node_name, $ip, $version, $node_key);
318 # NOTE: Corosync actually only resolves on startup or config change, but we
319 # currently do not have an easy way to synchronize our behaviour to that.
320 sub resolve_hostname_like_corosync
{
321 my ($hostname, $corosync_conf) = @_;
323 my $corosync_strategy = $corosync_conf->{main
}->{totem
}->{ip_version
};
324 $corosync_strategy = lc ($corosync_strategy // "ipv6-4");
326 my $match_ip_and_version = sub {
329 return undef if !defined($addr);
331 if ($addr =~ m/^$IPV4RE$/) {
333 } elsif ($addr =~ m/^$IPV6RE$/) {
340 my ($resolved_ip, $ip_version) = $match_ip_and_version->($hostname);
342 return ($resolved_ip, $ip_version) if defined($resolved_ip);
348 eval { @resolved_raw = PVE
::Tools
::getaddrinfo_all
($hostname); };
350 return undef if ($@ || !@resolved_raw);
352 foreach my $socket_info (@resolved_raw) {
353 next if !$socket_info->{addr
};
355 my ($family, undef, $host) = PVE
::Tools
::unpack_sockaddr_in46
($socket_info->{addr
});
357 if ($family == AF_INET
&& !defined($resolved_ip4)) {
358 $resolved_ip4 = inet_ntop
(AF_INET
, $host);
359 } elsif ($family == AF_INET6
&& !defined($resolved_ip6)) {
360 $resolved_ip6 = inet_ntop
(AF_INET6
, $host);
363 last if defined($resolved_ip4) && defined($resolved_ip6);
366 # corosync_strategy specifies the order in which IP addresses are resolved
367 # by corosync. We need to match that order, to ensure we create firewall
368 # rules for the correct address family.
369 if ($corosync_strategy eq "ipv4") {
370 $resolved_ip = $resolved_ip4;
371 } elsif ($corosync_strategy eq "ipv6") {
372 $resolved_ip = $resolved_ip6;
373 } elsif ($corosync_strategy eq "ipv6-4") {
374 $resolved_ip = $resolved_ip6 // $resolved_ip4;
375 } elsif ($corosync_strategy eq "ipv4-6") {
376 $resolved_ip = $resolved_ip4 // $resolved_ip6;
379 return $match_ip_and_version->($resolved_ip);