diff options
Diffstat (limited to 'scripts')
| -rwxr-xr-x | scripts/vrrp/vyatta-clear-vrrp.pl | 303 | ||||
| -rw-r--r-- | scripts/vrrp/vyatta-show-vrrp.pl | 114 |
2 files changed, 417 insertions, 0 deletions
diff --git a/scripts/vrrp/vyatta-clear-vrrp.pl b/scripts/vrrp/vyatta-clear-vrrp.pl new file mode 100755 index 0000000..34c0327 --- /dev/null +++ b/scripts/vrrp/vyatta-clear-vrrp.pl @@ -0,0 +1,303 @@ +#!/usr/bin/perl +# +# Module: vyatta-clear-vrrp.pl +# +# **** License **** +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# This code was originally developed by Vyatta, Inc. +# Portions created by Vyatta are Copyright (C) 2007-2009 Vyatta, Inc. +# All Rights Reserved. +# +# Author: Stig Thormodsrud +# Date: May 2008 +# Description: Script to clear vrrp +# +# **** End License **** +# + +use lib '/opt/vyatta/share/perl5/'; +use Vyatta::Keepalived; +use Vyatta::Interface; +use Vyatta::Misc; + +use Getopt::Long; +use Sys::Syslog qw(:standard :macros); + +use strict; +use warnings; + +my $conf_file = get_conf_file(); + + +sub keepalived_write_file { + my ($file, $data) = @_; + + open(my $fh, '>', $file) || die "Couldn't open $file - $!"; + print $fh $data; + close $fh; +} + +sub set_instance_inital_state { + my ($instance, $init) = @_; + + if ($init eq 'MASTER' and $instance =~ /state \s+ BACKUP/ix) { + if ($instance !~ s/state \s+ BACKUP/state MASTER/ix) { + print "Error: unable to replace BACKUP/MASTER\n"; + } + } elsif ($init eq 'BACKUP' and $instance =~ /state \s+ MASTER/ix) { + if ($instance !~ s/state \s+ MASTER/state BACKUP/ix) { + print "Error: unable to replace MASTER/BACKUP\n"; + } + } + return $instance; +} + +my $brace_block; + +sub vrrp_extract_instance { + my ($conf, $instance) = @_; + + # + # regex to find a balanced group of squiggly braces {{{ }}} + # + $brace_block = qr/ + \{ # 1st brace + ( + [^\{\}]+ # anything but brace + | # or + (??{ $brace_block }) # another brace_block + )* + \} # matching brace + /x; + + # + # regex to match instance: + # + # vrrp_instance vyatta-eth1.100-15 { + # state MASTER + # interface eth1 + # virtual_router_id 15 + # virtual_ipaddress { + # 1.1.1.1 + # } + # } + # + my $instance_regex = qr/(vrrp_instance \s+ $instance \s+ $brace_block)/x; + + # + # replace the instance with nothing + # + my $match_instance; + if ($conf =~ s/($instance_regex)//) { + $match_instance = $1; + } else { + return ($conf, undef); + } + + return ($conf, $match_instance); +} + +sub get_vrrp_intf_group { + my @array; + + # + # return an array of hashes that contains all the intf/group pairs + # + my $config = new Vyatta::Config; + + foreach my $name ( getInterfaces() ) { + my $intf = new Vyatta::Interface($name); + next unless $intf; + my $path = $intf->path(); + $config->setLevel($path); + if ($config->existsOrig('vrrp')) { + $path = "$path vrrp vrrp-group"; + $config->setLevel($path); + my @groups = $config->listOrigNodes(); + foreach my $group (@groups) { + my %hash; + $hash{'intf'} = $name; + $hash{'group'} = $group; + $hash{'path'} = "$path $group"; + push @array, {%hash}; + } + } + } + + return @array; +} + +sub set_inital_state { + my $conf = shift; + + my $new_conf = ''; + + # + # find all intf/groups, extract instance, set init state + # + my @vrrp_instances = get_vrrp_intf_group(); + + my $tmp_conf = $conf; + foreach my $hash (@vrrp_instances) { + my $intf = $hash->{'intf'}; + my $group = $hash->{'group'}; + my $instance = 'vyatta-' . "$intf" . '-' . "$group"; + my $match_instance; + ($tmp_conf, $match_instance) = + vrrp_extract_instance($tmp_conf, $instance); + if (defined $match_instance) { + my $init = vrrp_get_init_state($intf, $group, '', 'false'); + $match_instance = set_instance_inital_state($match_instance, $init); + $new_conf .= $match_instance . "\n\n"; + } + } + $new_conf = $tmp_conf . $new_conf; + + return $new_conf; +} + + +# +# main +# +my ($action, $vrrp_intf, $vrrp_group); + +GetOptions("vrrp-action=s" => \$action, + "intf=s" => \$vrrp_intf, + "group=s" => \$vrrp_group); + +if (! defined $action) { + print "no action\n"; + exit 1; +} + +openlog($0, '', LOG_USER); +my $login = getlogin(); + +# +# clear_process +# +if ($action eq 'clear_process') { + syslog('warning', "clear vrrp process requested by $login"); + if (Vyatta::Keepalived::is_running()) { + print "Restarting VRRP...\n"; + restart_daemon(get_conf_file()); + } else { + print "Starting VRRP...\n"; + start_daemon(get_conf_file()); + } + exit 0; +} + +# +# clear_master +# +if ($action eq 'clear_master') { + + # + # The kludge here to force a vrrp instance to switch from master to + # backup is to read the keepalived config, remove the instance to be + # cleared, signal the daemon to reread it's config. This will cause + # keepalived to see the old instance missing and send a priorty 0 + # advert to cause the backup to immediately take over master. Once + # that is done we put back the orginal config and signal the daemon + # again. Note: if the instance if preempt=true, then it may immediately + # try to become master again. + # + + if (! defined $vrrp_intf || ! defined $vrrp_group) { + print "must include interface & group\n"; + exit 1; + } + + my $instance = 'vyatta-' . "$vrrp_intf" . '-' . "$vrrp_group"; + my $state_file = Vyatta::Keepalived::get_state_file($vrrp_intf, $vrrp_group); + if (! -f $state_file) { + print "Invalid interface/group [$vrrp_intf][$vrrp_group]\n"; + exit 1; + } + + my ($start_time, $intf, $group, $state, $ltime) = + Vyatta::Keepalived::vrrp_state_parse($state_file); + if ($state ne 'master') { + print "vrrp group $vrrp_group on $vrrp_intf is already in backup\n"; + exit 1; + } + + syslog('warning', "clear vrrp master [$instance] requested by $login"); + Vyatta::Keepalived::vrrp_log("vrrp clear_master $vrrp_intf $vrrp_group"); + + # should add a file lock + local($/); # slurp mode + open my $f, '<', $conf_file or die "Couldn't open $conf_file\n"; + my $conf = <$f>; + close $f; + + my $sync_group = list_vrrp_sync_group($intf, $group); + my @instances = (); + if (defined($sync_group)) { + print "vrrp group $vrrp_group on $vrrp_intf is in sync-group " + . "$sync_group\n"; + @instances = list_vrrp_sync_group_members($sync_group); + } else { + push @instances, $instance; + } + + my $new_conf = $conf; + my $clear_instances; + foreach my $inst (@instances) { + my $match_instance; + print "Forcing $inst to BACKUP...\n"; + Vyatta::Keepalived::vrrp_log("vrrp extract $inst"); + ($new_conf, $match_instance) = vrrp_extract_instance($new_conf, $inst); + if ($match_instance !~ /nopreempt/) { + print "Warning: $instance is in preempt mode"; + print " and may retake master\n"; + + } + $match_instance = set_instance_inital_state($match_instance, 'BACKUP'); + $clear_instances .= "$match_instance\n"; + } + + # + # need to set the correct initial state for the remaining instances + # + $new_conf = set_inital_state($new_conf); + + # + # create the temporary config file + # + my $tmp_conf_file = $conf_file . ".$$"; + keepalived_write_file($tmp_conf_file, $new_conf); + + my $conf_file_bak = $conf_file . '.bak'; + system("mv $conf_file $conf_file_bak"); + system("cp $tmp_conf_file $conf_file"); + + restart_daemon($conf_file); + + sleep(3); + + # + # add modified instance back and restart + # + $new_conf .= "\n" . $clear_instances . "\n"; + + keepalived_write_file($conf_file, $new_conf); + Vyatta::Keepalived::restart_daemon($conf_file); + + system("rm $conf_file_bak $tmp_conf_file"); + exit 0; +} + +exit 0; + +# end of file diff --git a/scripts/vrrp/vyatta-show-vrrp.pl b/scripts/vrrp/vyatta-show-vrrp.pl new file mode 100644 index 0000000..afc490b --- /dev/null +++ b/scripts/vrrp/vyatta-show-vrrp.pl @@ -0,0 +1,114 @@ +#!/usr/bin/env perl +# +# **** License **** +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# This code was originally developed by Vyatta, Inc. +# Portions created by Vyatta are Copyright (C) 2007-2012 Vyatta, Inc. +# All Rights Reserved. +# +# Author: John Southworth +# Date: May 2012 +# Description: Process operational data from keepalived +# +# **** End License **** +# + +use strict; +use lib "/opt/vyatta/share/perl5"; + +use Getopt::Long; +use Vyatta::VRRP::OPMode; +use Sort::Versions; +use v5.10; + +my ($show, $intf, $vrid); +GetOptions("show=s" => \$show, + "intf=s" => \$intf, + "vrid=s" => \$vrid + ); + +sub list_vrrp_intf { + my $intf = shift; + my $hash = {}; + process_data $hash; + if ($intf) { + printf "%s\n", join " ", sort versioncmp keys(%{$hash->{instances}->{$intf}}); + } else { + printf "%s\n", join " ", sort versioncmp keys(%{$hash->{instances}}); + } +} + +sub list_vrrp_sync_groups { + my $hash = {}; + process_data $hash; + printf "%s\n", join " ", sort versioncmp keys(%{$hash->{'sync-groups'}}); +} + +sub show_vrrp_summary { + my ($intf, $vrid) = @_; + my $hash = {}; + process_data $hash; + return if (check_intf($hash, $intf, $vrid)); + print_summary $hash, $intf, $vrid; +} + +sub show_vrrp_stats { + my ($intf, $vrid) = @_; + my $hash = {}; + process_stats $hash; + return if (check_intf($hash, $intf, $vrid)); + print_stats $hash, $intf, $vrid; +} + +sub show_vrrp_detail { + my ($intf, $vrid) = @_; + my $hash = {}; + process_data $hash; + return if (check_intf($hash, $intf, $vrid)); + print_detail $hash, $intf, $vrid; +} + +sub show_vrrp_sync_groups { + my $sync = shift; + my $hash = {}; + process_data $hash; + if ($sync && !exists($hash->{'sync-groups'}->{$sync})){ + print "Sync-group: $sync does not exist\n"; + return; + } + print_sync $hash, $intf; +} + +given ($show) { + when ('summary') { + show_vrrp_summary $intf, $vrid; + } + when ('detail') { + show_vrrp_detail $intf, $vrid; + } + when ('stats') { + show_vrrp_stats $intf, $vrid; + } + when ('sync') { + show_vrrp_sync_groups $intf; + } + when ('interface') { + list_vrrp_intf $intf; + } + when ('syncs') { + list_vrrp_sync_groups; + } + default { + exit; + } +} + + |