[pve-network.git] / PVE / Network / SDN / Controllers / EvpnPlugin.pm

package PVE::Network::SDN::Controllers::EvpnPlugin;

use strict;
use warnings;

use PVE::INotify;
use PVE::JSONSchema qw(get_standard_option);
use PVE::Tools qw(run_command file_set_contents file_get_contents);

use PVE::Network::SDN::Controllers::Plugin;
use PVE::Network::SDN::Zones::Plugin;
use Net::IP;

use base('PVE::Network::SDN::Controllers::Plugin');

sub type {
    return 'evpn';
}

sub properties {
    return {
	asn => {
	    type => 'integer',
	    description => "autonomous system number",
	    minimum => 0,
	    maximum => 4294967296
	},
	peers => {
	    description => "peers address list.",
	    type => 'string', format => 'ip-list'
	},
    };
}

sub options {
    return {
	'asn' => { optional => 0 },
	'peers' => { optional => 0 },
    };
}

# Plugin implementation
sub generate_controller_config {
    my ($class, $plugin_config, $controller_cfg, $id, $uplinks, $config) = @_;

    my @peers;
    @peers = PVE::Tools::split_list($plugin_config->{'peers'}) if $plugin_config->{'peers'};

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

    my $asn = $plugin_config->{asn};
    my $ebgp = undef;
    my $loopback = undef;
    my $autortas = undef;
    my $bgprouter = find_bgp_controller($local_node, $controller_cfg);
    if($bgprouter) {
	$ebgp = 1 if $plugin_config->{'asn'} ne $bgprouter->{asn};
	$loopback = $bgprouter->{loopback} if $bgprouter->{loopback};
	$asn = $bgprouter->{asn} if $bgprouter->{asn};
	$autortas = $plugin_config->{'asn'} if $ebgp;
    }

    return if !$asn;

    my $bgp = $config->{frr}->{router}->{"bgp $asn"} //= {};

    my ($ifaceip, $interface) = PVE::Network::SDN::Zones::Plugin::find_local_ip_interface_peers(\@peers, $loopback);

    my $remoteas = $ebgp ? "external" : $asn;

    #global options
    my @controller_config = (
	"bgp router-id $ifaceip",
	"no bgp default ipv4-unicast",
	"coalesce-time 1000",
    );

    push(@{$bgp->{""}}, @controller_config) if keys %{$bgp} == 0;

    @controller_config = ();
    
    #VTEP neighbors
    push @controller_config, "neighbor VTEP peer-group";
    push @controller_config, "neighbor VTEP remote-as $remoteas";
    push @controller_config, "neighbor VTEP bfd";

    if($ebgp && $loopback) {
	push @controller_config, "neighbor VTEP ebgp-multihop 10";
	push @controller_config, "neighbor VTEP update-source $loopback";
    }

    # VTEP peers
    foreach my $address (@peers) {
	next if $address eq $ifaceip;
	push @controller_config, "neighbor $address peer-group VTEP";
    }

    push(@{$bgp->{""}}, @controller_config);

    # address-family l2vpn
    @controller_config = ();
    push @controller_config, "neighbor VTEP route-map MAP_VTEP_OUT out";
    push @controller_config, "neighbor VTEP activate";
    push @controller_config, "advertise-all-vni";
    push @controller_config, "autort as $autortas" if $autortas;
    push(@{$bgp->{"address-family"}->{"l2vpn evpn"}}, @controller_config);

    push(@{$config->{frr_routemap}->{'MAP_VTEP_OUT'}}, []);

    return $config;
}

sub generate_controller_zone_config {
    my ($class, $plugin_config, $controller, $controller_cfg, $id, $uplinks, $config) = @_;

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

    my $vrf = "vrf_$id";
    my $vrfvxlan = $plugin_config->{'vrf-vxlan'};
    my $exitnodes = $plugin_config->{'exitnodes'};
    my $exitnodes_primary = $plugin_config->{'exitnodes-primary'};
    my $advertisesubnets = $plugin_config->{'advertise-subnets'};
    my $exitnodes_local_routing = $plugin_config->{'exitnodes-local-routing'};
    my $rt_import = [PVE::Tools::split_list($plugin_config->{'rt-import'})] if $plugin_config->{'rt-import'};

    my $asn = $controller->{asn};
    my @peers = PVE::Tools::split_list($controller->{'peers'}) if $controller->{'peers'};
    my $ebgp = undef;
    my $loopback = undef;
    my $autortas = undef;
    my $bgprouter = find_bgp_controller($local_node, $controller_cfg);
    if($bgprouter) {
        $ebgp = 1 if $controller->{'asn'} ne $bgprouter->{asn};
	$loopback = $bgprouter->{loopback} if $bgprouter->{loopback};
	$asn = $bgprouter->{asn} if $bgprouter->{asn};
	$autortas = $controller->{'asn'} if $ebgp;
    }

    return if !$vrf || !$vrfvxlan || !$asn;

    my ($ifaceip, $interface) = PVE::Network::SDN::Zones::Plugin::find_local_ip_interface_peers(\@peers, $loopback);

    # vrf
    my @controller_config = ();
    push @controller_config, "vni $vrfvxlan";
    push(@{$config->{frr}->{vrf}->{"$vrf"}}, @controller_config);

    #main vrf router
    @controller_config = ();
    push @controller_config, "bgp router-id $ifaceip";
    push @controller_config, "no bgp ebgp-requires-policy" if $ebgp;
#    push @controller_config, "!";
    push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{""}}, @controller_config);

    if ($autortas) {
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, "route-target import $autortas:$vrfvxlan");
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, "route-target export $autortas:$vrfvxlan");
    }

    my $is_gateway = $exitnodes->{$local_node};

    if ($is_gateway) {

        if($exitnodes_primary && $exitnodes_primary ne $local_node) {
	    my $routemap_config = ();
	    push @{$routemap_config}, "match evpn vni $vrfvxlan";
	    push @{$routemap_config}, "match evpn route-type prefix";
	    push @{$routemap_config}, "set metric 200";
	    unshift(@{$config->{frr_routemap}->{'MAP_VTEP_OUT'}}, $routemap_config);
        }

	if (!$exitnodes_local_routing) {
	    @controller_config = ();
	    #import /32 routes of evpn network from vrf1 to default vrf (for packet return)
	    push @controller_config, "import vrf $vrf";
	    push(@{$config->{frr}->{router}->{"bgp $asn"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	    push(@{$config->{frr}->{router}->{"bgp $asn"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);

	    @controller_config = ();
	    #redistribute connected to be able to route to local vms on the gateway
	    push @controller_config, "redistribute connected";
	    push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	    push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);
	}

	@controller_config = ();
	#add default originate to announce 0.0.0.0/0 type5 route in evpn
	push @controller_config, "default-originate ipv4";
	push @controller_config, "default-originate ipv6";
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
    } elsif ($advertisesubnets) {

	@controller_config = ();
	#redistribute connected networks
	push @controller_config, "redistribute connected";
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);

	@controller_config = ();
	#advertise connected networks type5 route in evpn
	push @controller_config, "advertise ipv4 unicast";
	push @controller_config, "advertise ipv6 unicast";
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
    }

    if($rt_import) {
	@controller_config = ();
	foreach my $rt (sort @{$rt_import}) {
	    push @controller_config, "route-target import $rt";
	}
	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
    }

    return $config;
}

sub generate_controller_vnet_config {
    my ($class, $plugin_config, $controller, $zone, $zoneid, $vnetid, $config) = @_;

    my $exitnodes = $zone->{'exitnodes'};
    my $exitnodes_local_routing = $zone->{'exitnodes-local-routing'};

    return if !$exitnodes_local_routing;

    my $local_node = PVE::INotify::nodename();
    my $is_gateway = $exitnodes->{$local_node};
    
    return if !$is_gateway;

    my $subnets = PVE::Network::SDN::Vnets::get_subnets($vnetid, 1);
    my @controller_config = ();
    foreach my $subnetid (sort keys %{$subnets}) {
        my $subnet = $subnets->{$subnetid};
	my $cidr = $subnet->{cidr};
	push @controller_config, "ip route $cidr 10.255.255.2 xvrf_$zoneid";
    }
    push(@{$config->{frr}->{''}}, @controller_config);
}

sub on_delete_hook {
    my ($class, $controllerid, $zone_cfg) = @_;

    # verify that zone is associated to this controller
    foreach my $id (keys %{$zone_cfg->{ids}}) {
	my $zone = $zone_cfg->{ids}->{$id};
	die "controller $controllerid is used by $id"
	    if (defined($zone->{controller}) && $zone->{controller} eq $controllerid);
    }
}

sub on_update_hook {
    my ($class, $controllerid, $controller_cfg) = @_;

    # we can only have 1 evpn controller / 1 asn by server

    my $controllernb = 0;
    foreach my $id (keys %{$controller_cfg->{ids}}) {
	next if $id eq $controllerid;
	my $controller = $controller_cfg->{ids}->{$id};
	next if $controller->{type} ne "evpn";
	$controllernb++;
	die "only 1 global evpn controller can be defined" if $controllernb > 1;
    }
}

sub find_bgp_controller {
    my ($nodename, $controller_cfg) = @_;

    my $controller = undef;
    foreach my $id  (keys %{$controller_cfg->{ids}}) {
        $controller = $controller_cfg->{ids}->{$id};
        next if $controller->{type} ne 'bgp';
        next if $controller->{node} ne $nodename;
	last;
    }

    return $controller;
}


sub sort_frr_config {
    my $order = {};
    $order->{''} = 0;
    $order->{'vrf'} = 1;
    $order->{'ipv4 unicast'} = 1;
    $order->{'ipv6 unicast'} = 2;
    $order->{'l2vpn evpn'} = 3;

    my $a_val = 100;
    my $b_val = 100;

    $a_val = $order->{$a} if defined($order->{$a});
    $b_val = $order->{$b} if defined($order->{$b});

    if ($a =~ /bgp (\d+)$/) {
	$a_val = 2;
    }

    if ($b =~ /bgp (\d+)$/) {
	$b_val = 2;
    }

    return $a_val <=> $b_val;
}

sub generate_frr_recurse{
   my ($final_config, $content, $parentkey, $level) = @_;

   my $keylist = {};
   $keylist->{vrf} = 1;
   $keylist->{'address-family'} = 1;
   $keylist->{router} = 1;

   my $exitkeylist = {};
   $exitkeylist->{vrf} = 1;
   $exitkeylist->{'address-family'} = 1;

   # FIXME: make this generic
   my $paddinglevel = undef;
   if ($level == 1 || $level == 2) {
	$paddinglevel = $level - 1;
   } elsif ($level == 3 || $level ==  4) {
	$paddinglevel = $level - 2;
   }

   my $padding = "";
   $padding = ' ' x ($paddinglevel) if $paddinglevel;

   if (ref $content eq  'HASH') {
	foreach my $key (sort sort_frr_config keys %$content) {
	    if ($parentkey && defined($keylist->{$parentkey})) {
		push @{$final_config}, $padding."!";
		push @{$final_config}, $padding."$parentkey $key";
	    } elsif ($key ne '' && !defined($keylist->{$key})) {
		push @{$final_config}, $padding."$key";
	    }

	    my $option = $content->{$key};
	    generate_frr_recurse($final_config, $option, $key, $level+1);

	    push @{$final_config}, $padding."exit-$parentkey" if $parentkey && defined($exitkeylist->{$parentkey});
	}
    }

    if (ref $content eq 'ARRAY') {
	push @{$final_config}, map { $padding . "$_" } @$content;
    }
}

sub generate_frr_routemap {
   my ($final_config, $routemaps) = @_;

   foreach my $id (sort keys %$routemaps) {

	my $routemap = $routemaps->{$id};
	my $order = 0;
	foreach my $seq (@$routemap) {
		$order++;
		my @config = ();
		push @config, "!";
		push @config, "route-map $id permit $order";
		push @config, map { " $_" } @$seq;
		push @{$final_config}, @config;
	}
   }
}
sub generate_controller_rawconfig {
    my ($class, $plugin_config, $config) = @_;

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

    my $final_config = [];
    push @{$final_config}, "log syslog informational";
    push @{$final_config}, "ip forwarding";
    push @{$final_config}, "ipv6 forwarding";
    push @{$final_config}, "frr defaults datacenter";
    push @{$final_config}, "service integrated-vtysh-config";
    push @{$final_config}, "hostname $nodename";
    push @{$final_config}, "!";

    if (-e "/etc/frr/frr.conf.local") {
	generate_frr_recurse($final_config, $config->{frr}->{vrf}, "vrf", 1);
	generate_frr_routemap($final_config, $config->{frr_routemap});
	push @{$final_config}, "!";

	my $local_conf = file_get_contents("/etc/frr/frr.conf.local");
	chomp ($local_conf);
	push @{$final_config}, $local_conf;
    } else {
	generate_frr_recurse($final_config, $config->{frr}, undef, 0);
	generate_frr_routemap($final_config, $config->{frr_routemap});
    }

    push @{$final_config}, "!";
    push @{$final_config}, "line vty";
    push @{$final_config}, "!";

    my $rawconfig = join("\n", @{$final_config});

    return if !$rawconfig;
    return $rawconfig;
}

sub write_controller_config {
    my ($class, $plugin_config, $config) = @_;

    my $rawconfig = $class->generate_controller_rawconfig($plugin_config, $config);
    return if !$rawconfig;
    return if !-d "/etc/frr";

    file_set_contents("/etc/frr/frr.conf", $rawconfig);
}

sub reload_controller {
    my ($class) = @_;

    my $conf_file = "/etc/frr/frr.conf";
    my $bin_path = "/usr/lib/frr/frr-reload.py";

    if (!-e $bin_path) {
	warn "missing $bin_path. Please install frr-pythontools package";
	return;
    }

    my $err = sub {
	my $line = shift;
	if ($line =~ /ERROR:/) {
	    warn "$line \n";
	}
    };

    if (-e $conf_file && -e $bin_path) {
	run_command([$bin_path, '--stdout', '--reload', $conf_file], outfunc => {}, errfunc => $err);
    }
}

1;
Commit	Line	Data
fa253735	1	package PVE::Network::SDN::Controllers::EvpnPlugin;
32602a38 AD	2
	3	use strict;
	4	use warnings;
cdf2c819	5
074d270b AD	6	use PVE::INotify;
074d270b AD	7	use PVE::JSONSchema qw(get_standard_option);
cdf2c819 TL	8	use PVE::Tools qw(run_command file_set_contents file_get_contents);
	9
	10	use PVE::Network::SDN::Controllers::Plugin;
1f543c5f	11	use PVE::Network::SDN::Zones::Plugin;
f23633dc	12	use Net::IP;
cdf2c819	13
f5eabba0	14	use base('PVE::Network::SDN::Controllers::Plugin');
32602a38 AD	15
32602a38 AD	16	sub type {
fa253735	17	return 'evpn';
8fb1ee7f AD	18	}
8fb1ee7f AD	19
32602a38 AD	20	sub properties {
32602a38 AD	21	return {
92526f0e TL	22	asn => {
	23	type => 'integer',
	24	description => "autonomous system number",
9e6b99fd AD	25	minimum => 0,
9e6b99fd AD	26	maximum => 4294967296
92526f0e TL	27	},
	28	peers => {
	29	description => "peers address list.",
	30	type => 'string', format => 'ip-list'
	31	},
32602a38 AD	32	};
	33	}
	34
	35	sub options {
32602a38	36	return {
92526f0e TL	37	'asn' => { optional => 0 },
92526f0e TL	38	'peers' => { optional => 0 },
32602a38 AD	39	};
	40	}
	41
	42	# Plugin implementation
8fb1ee7f	43	sub generate_controller_config {
f23633dc	44	my ($class, $plugin_config, $controller_cfg, $id, $uplinks, $config) = @_;
32602a38	45
3caa7687 FG	46	my @peers;
3caa7687 FG	47	@peers = PVE::Tools::split_list($plugin_config->{'peers'}) if $plugin_config->{'peers'};
32602a38	48
f23633dc AD	49	my $local_node = PVE::INotify::nodename();
f23633dc AD	50
074d270b	51	my $asn = $plugin_config->{asn};
f23633dc AD	52	my $ebgp = undef;
	53	my $loopback = undef;
	54	my $autortas = undef;
	55	my $bgprouter = find_bgp_controller($local_node, $controller_cfg);
	56	if($bgprouter) {
	57	$ebgp = 1 if $plugin_config->{'asn'} ne $bgprouter->{asn};
	58	$loopback = $bgprouter->{loopback} if $bgprouter->{loopback};
	59	$asn = $bgprouter->{asn} if $bgprouter->{asn};
	60	$autortas = $plugin_config->{'asn'} if $ebgp;
	61	}
074d270b AD	62
074d270b AD	63	return if !$asn;
32602a38	64
92526f0e TL	65	my $bgp = $config->{frr}->{router}->{"bgp $asn"} //= {};
92526f0e TL	66
f23633dc	67	my ($ifaceip, $interface) = PVE::Network::SDN::Zones::Plugin::find_local_ip_interface_peers(\@peers, $loopback);
32602a38	68
f23633dc	69	my $remoteas = $ebgp ? "external" : $asn;
17854295	70
f23633dc	71	#global options
92526f0e TL	72	my @controller_config = (
	73	"bgp router-id $ifaceip",
	74	"no bgp default ipv4-unicast",
	75	"coalesce-time 1000",
	76	);
32602a38	77
f23633dc AD	78	push(@{$bgp->{""}}, @controller_config) if keys %{$bgp} == 0;
	79
	80	@controller_config = ();
	81
	82	#VTEP neighbors
	83	push @controller_config, "neighbor VTEP peer-group";
	84	push @controller_config, "neighbor VTEP remote-as $remoteas";
	85	push @controller_config, "neighbor VTEP bfd";
	86
	87	if($ebgp && $loopback) {
	88	push @controller_config, "neighbor VTEP ebgp-multihop 10";
	89	push @controller_config, "neighbor VTEP update-source $loopback";
	90	}
	91
	92	# VTEP peers
32602a38 AD	93	foreach my $address (@peers) {
32602a38 AD	94	next if $address eq $ifaceip;
f23633dc	95	push @controller_config, "neighbor $address peer-group VTEP";
7d35eaf5	96	}
074d270b	97
92526f0e	98	push(@{$bgp->{""}}, @controller_config);
074d270b	99
f23633dc	100	# address-family l2vpn
56cdcac9	101	@controller_config = ();
847f5144	102	push @controller_config, "neighbor VTEP route-map MAP_VTEP_OUT out";
f23633dc	103	push @controller_config, "neighbor VTEP activate";
56cdcac9	104	push @controller_config, "advertise-all-vni";
f23633dc	105	push @controller_config, "autort as $autortas" if $autortas;
92526f0e	106	push(@{$bgp->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
32602a38	107
847f5144 AD	108	push(@{$config->{frr_routemap}->{'MAP_VTEP_OUT'}}, []);
847f5144 AD	109
32602a38 AD	110	return $config;
	111	}
	112
56cdcac9	113	sub generate_controller_zone_config {
f23633dc AD	114	my ($class, $plugin_config, $controller, $controller_cfg, $id, $uplinks, $config) = @_;
	115
	116	my $local_node = PVE::INotify::nodename();
0589eb09	117
1de0abc0	118	my $vrf = "vrf_$id";
0589eb09	119	my $vrfvxlan = $plugin_config->{'vrf-vxlan'};
f23633dc	120	my $exitnodes = $plugin_config->{'exitnodes'};
847f5144	121	my $exitnodes_primary = $plugin_config->{'exitnodes-primary'};
92d8effb	122	my $advertisesubnets = $plugin_config->{'advertise-subnets'};
3d135423	123	my $exitnodes_local_routing = $plugin_config->{'exitnodes-local-routing'};
96794fd6	124	my $rt_import = [PVE::Tools::split_list($plugin_config->{'rt-import'})] if $plugin_config->{'rt-import'};
f23633dc	125
56cdcac9	126	my $asn = $controller->{asn};
f34a898e	127	my @peers = PVE::Tools::split_list($controller->{'peers'}) if $controller->{'peers'};
f23633dc AD	128	my $ebgp = undef;
	129	my $loopback = undef;
	130	my $autortas = undef;
	131	my $bgprouter = find_bgp_controller($local_node, $controller_cfg);
	132	if($bgprouter) {
	133	$ebgp = 1 if $controller->{'asn'} ne $bgprouter->{asn};
	134	$loopback = $bgprouter->{loopback} if $bgprouter->{loopback};
	135	$asn = $bgprouter->{asn} if $bgprouter->{asn};
	136	$autortas = $controller->{'asn'} if $ebgp;
	137	}
0589eb09 AD	138
	139	return if !$vrf \|\| !$vrfvxlan \|\| !$asn;
	140
f34a898e AD	141	my ($ifaceip, $interface) = PVE::Network::SDN::Zones::Plugin::find_local_ip_interface_peers(\@peers, $loopback);
f34a898e AD	142
92526f0e	143	# vrf
56cdcac9 AD	144	my @controller_config = ();
	145	push @controller_config, "vni $vrfvxlan";
	146	push(@{$config->{frr}->{vrf}->{"$vrf"}}, @controller_config);
0589eb09	147
f23633dc AD	148	#main vrf router
f23633dc AD	149	@controller_config = ();
f34a898e	150	push @controller_config, "bgp router-id $ifaceip";
f23633dc AD	151	push @controller_config, "no bgp ebgp-requires-policy" if $ebgp;
	152	# push @controller_config, "!";
	153	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{""}}, @controller_config);
659c27c2	154
f23633dc AD	155	if ($autortas) {
	156	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, "route-target import $autortas:$vrfvxlan");
	157	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, "route-target export $autortas:$vrfvxlan");
	158	}
0589eb09	159
b634e577 AD	160	my $is_gateway = $exitnodes->{$local_node};
b634e577 AD	161
0589eb09 AD	162	if ($is_gateway) {
0589eb09 AD	163
847f5144 AD	164	if($exitnodes_primary && $exitnodes_primary ne $local_node) {
	165	my $routemap_config = ();
	166	push @{$routemap_config}, "match evpn vni $vrfvxlan";
	167	push @{$routemap_config}, "match evpn route-type prefix";
	168	push @{$routemap_config}, "set metric 200";
	169	unshift(@{$config->{frr_routemap}->{'MAP_VTEP_OUT'}}, $routemap_config);
	170	}
	171
3d135423 AD	172	if (!$exitnodes_local_routing) {
	173	@controller_config = ();
	174	#import /32 routes of evpn network from vrf1 to default vrf (for packet return)
	175	push @controller_config, "import vrf $vrf";
	176	push(@{$config->{frr}->{router}->{"bgp $asn"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	177	push(@{$config->{frr}->{router}->{"bgp $asn"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);
0589eb09	178
3d135423 AD	179	@controller_config = ();
	180	#redistribute connected to be able to route to local vms on the gateway
	181	push @controller_config, "redistribute connected";
	182	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	183	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);
	184	}
0589eb09	185
56cdcac9	186	@controller_config = ();
0589eb09	187	#add default originate to announce 0.0.0.0/0 type5 route in evpn
56cdcac9 AD	188	push @controller_config, "default-originate ipv4";
	189	push @controller_config, "default-originate ipv6";
	190	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
92d8effb AD	191	} elsif ($advertisesubnets) {
	192
	193	@controller_config = ();
	194	#redistribute connected networks
	195	push @controller_config, "redistribute connected";
	196	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv4 unicast"}}, @controller_config);
	197	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"ipv6 unicast"}}, @controller_config);
	198
	199	@controller_config = ();
	200	#advertise connected networks type5 route in evpn
	201	push @controller_config, "advertise ipv4 unicast";
	202	push @controller_config, "advertise ipv6 unicast";
	203	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
0589eb09 AD	204	}
0589eb09 AD	205
96794fd6 AD	206	if($rt_import) {
	207	@controller_config = ();
	208	foreach my $rt (sort @{$rt_import}) {
	209	push @controller_config, "route-target import $rt";
	210	}
	211	push(@{$config->{frr}->{router}->{"bgp $asn vrf $vrf"}->{"address-family"}->{"l2vpn evpn"}}, @controller_config);
	212	}
	213
0589eb09 AD	214	return $config;
	215	}
	216
3d135423 AD	217	sub generate_controller_vnet_config {
	218	my ($class, $plugin_config, $controller, $zone, $zoneid, $vnetid, $config) = @_;
	219
	220	my $exitnodes = $zone->{'exitnodes'};
	221	my $exitnodes_local_routing = $zone->{'exitnodes-local-routing'};
	222
	223	return if !$exitnodes_local_routing;
	224
	225	my $local_node = PVE::INotify::nodename();
	226	my $is_gateway = $exitnodes->{$local_node};
	227
	228	return if !$is_gateway;
	229
	230	my $subnets = PVE::Network::SDN::Vnets::get_subnets($vnetid, 1);
	231	my @controller_config = ();
	232	foreach my $subnetid (sort keys %{$subnets}) {
	233	my $subnet = $subnets->{$subnetid};
	234	my $cidr = $subnet->{cidr};
	235	push @controller_config, "ip route $cidr 10.255.255.2 xvrf_$zoneid";
	236	}
	237	push(@{$config->{frr}->{''}}, @controller_config);
	238	}
	239
32602a38	240	sub on_delete_hook {
56cdcac9	241	my ($class, $controllerid, $zone_cfg) = @_;
32602a38	242
56cdcac9 AD	243	# verify that zone is associated to this controller
56cdcac9 AD	244	foreach my $id (keys %{$zone_cfg->{ids}}) {
92526f0e TL	245	my $zone = $zone_cfg->{ids}->{$id};
	246	die "controller $controllerid is used by $id"
	247	if (defined($zone->{controller}) && $zone->{controller} eq $controllerid);
5bda8607	248	}
32602a38 AD	249	}
	250
	251	sub on_update_hook {
56cdcac9	252	my ($class, $controllerid, $controller_cfg) = @_;
5bda8607	253
c7bb4ac5 AD	254	# we can only have 1 evpn controller / 1 asn by server
c7bb4ac5 AD	255
f23633dc	256	my $controllernb = 0;
56cdcac9 AD	257	foreach my $id (keys %{$controller_cfg->{ids}}) {
56cdcac9 AD	258	next if $id eq $controllerid;
92526f0e	259	my $controller = $controller_cfg->{ids}->{$id};
f23633dc AD	260	next if $controller->{type} ne "evpn";
	261	$controllernb++;
	262	die "only 1 global evpn controller can be defined" if $controllernb > 1;
	263	}
	264	}
	265
	266	sub find_bgp_controller {
	267	my ($nodename, $controller_cfg) = @_;
	268
	269	my $controller = undef;
	270	foreach my $id (keys %{$controller_cfg->{ids}}) {
	271	$controller = $controller_cfg->{ids}->{$id};
	272	next if $controller->{type} ne 'bgp';
	273	next if $controller->{node} ne $nodename;
	274	last;
5bda8607	275	}
f23633dc AD	276
f23633dc AD	277	return $controller;
32602a38 AD	278	}
32602a38 AD	279
f23633dc	280
8fb1ee7f AD	281	sub sort_frr_config {
	282	my $order = {};
	283	$order->{''} = 0;
	284	$order->{'vrf'} = 1;
	285	$order->{'ipv4 unicast'} = 1;
	286	$order->{'ipv6 unicast'} = 2;
	287	$order->{'l2vpn evpn'} = 3;
	288
	289	my $a_val = 100;
	290	my $b_val = 100;
	291
	292	$a_val = $order->{$a} if defined($order->{$a});
	293	$b_val = $order->{$b} if defined($order->{$b});
	294
92526f0e	295	if ($a =~ /bgp (\d+)$/) {
8fb1ee7f AD	296	$a_val = 2;
	297	}
	298
92526f0e	299	if ($b =~ /bgp (\d+)$/) {
8fb1ee7f AD	300	$b_val = 2;
	301	}
	302
	303	return $a_val <=> $b_val;
	304	}
	305
	306	sub generate_frr_recurse{
	307	my ($final_config, $content, $parentkey, $level) = @_;
	308
	309	my $keylist = {};
	310	$keylist->{vrf} = 1;
	311	$keylist->{'address-family'} = 1;
	312	$keylist->{router} = 1;
	313
	314	my $exitkeylist = {};
	315	$exitkeylist->{vrf} = 1;
	316	$exitkeylist->{'address-family'} = 1;
	317
92526f0e	318	# FIXME: make this generic
8fb1ee7f	319	my $paddinglevel = undef;
92526f0e TL	320	if ($level == 1 \|\| $level == 2) {
92526f0e TL	321	$paddinglevel = $level - 1;
8fb1ee7f	322	} elsif ($level == 3 \|\| $level == 4) {
92526f0e	323	$paddinglevel = $level - 2;
8fb1ee7f AD	324	}
	325
	326	my $padding = "";
	327	$padding = ' ' x ($paddinglevel) if $paddinglevel;
	328
92526f0e	329	if (ref $content eq 'HASH') {
8fb1ee7f AD	330	foreach my $key (sort sort_frr_config keys %$content) {
8fb1ee7f AD	331	if ($parentkey && defined($keylist->{$parentkey})) {
92526f0e TL	332	push @{$final_config}, $padding."!";
	333	push @{$final_config}, $padding."$parentkey $key";
	334	} elsif ($key ne '' && !defined($keylist->{$key})) {
	335	push @{$final_config}, $padding."$key";
8fb1ee7f AD	336	}
	337
	338	my $option = $content->{$key};
	339	generate_frr_recurse($final_config, $option, $key, $level+1);
	340
	341	push @{$final_config}, $padding."exit-$parentkey" if $parentkey && defined($exitkeylist->{$parentkey});
	342	}
	343	}
32602a38	344
8fb1ee7f	345	if (ref $content eq 'ARRAY') {
92526f0e	346	push @{$final_config}, map { $padding . "$_" } @$content;
8fb1ee7f AD	347	}
	348	}
	349
847f5144 AD	350	sub generate_frr_routemap {
	351	my ($final_config, $routemaps) = @_;
	352
	353	foreach my $id (sort keys %$routemaps) {
	354
	355	my $routemap = $routemaps->{$id};
	356	my $order = 0;
	357	foreach my $seq (@$routemap) {
	358	$order++;
	359	my @config = ();
	360	push @config, "!";
	361	push @config, "route-map $id permit $order";
	362	push @config, map { " $_" } @$seq;
	363	push @{$final_config}, @config;
	364	}
	365	}
	366	}
9cef13e9	367	sub generate_controller_rawconfig {
8fb1ee7f AD	368	my ($class, $plugin_config, $config) = @_;
8fb1ee7f AD	369
659c27c2 AD	370	my $nodename = PVE::INotify::nodename();
659c27c2 AD	371
8fb1ee7f AD	372	my $final_config = [];
8fb1ee7f AD	373	push @{$final_config}, "log syslog informational";
659c27c2 AD	374	push @{$final_config}, "ip forwarding";
659c27c2 AD	375	push @{$final_config}, "ipv6 forwarding";
67a0f815	376	push @{$final_config}, "frr defaults datacenter";
659c27c2 AD	377	push @{$final_config}, "service integrated-vtysh-config";
659c27c2 AD	378	push @{$final_config}, "hostname $nodename";
8fb1ee7f AD	379	push @{$final_config}, "!";
8fb1ee7f AD	380
0d1ab7dc	381	if (-e "/etc/frr/frr.conf.local") {
0d1ab7dc	382	generate_frr_recurse($final_config, $config->{frr}->{vrf}, "vrf", 1);
847f5144	383	generate_frr_routemap($final_config, $config->{frr_routemap});
0d1ab7dc AD	384	push @{$final_config}, "!";
0d1ab7dc AD	385
cdf2c819 TL	386	my $local_conf = file_get_contents("/etc/frr/frr.conf.local");
	387	chomp ($local_conf);
	388	push @{$final_config}, $local_conf;
0d1ab7dc AD	389	} else {
0d1ab7dc AD	390	generate_frr_recurse($final_config, $config->{frr}, undef, 0);
847f5144	391	generate_frr_routemap($final_config, $config->{frr_routemap});
0d1ab7dc	392	}
8fb1ee7f AD	393
	394	push @{$final_config}, "!";
	395	push @{$final_config}, "line vty";
	396	push @{$final_config}, "!";
	397
	398	my $rawconfig = join("\n", @{$final_config});
	399
9cef13e9 AD	400	return if !$rawconfig;
	401	return $rawconfig;
	402	}
	403
	404	sub write_controller_config {
	405	my ($class, $plugin_config, $config) = @_;
	406
	407	my $rawconfig = $class->generate_controller_rawconfig($plugin_config, $config);
8fb1ee7f AD	408	return if !$rawconfig;
	409	return if !-d "/etc/frr";
	410
cdf2c819	411	file_set_contents("/etc/frr/frr.conf", $rawconfig);
8fb1ee7f AD	412	}
8fb1ee7f AD	413
fa609bdd AD	414	sub reload_controller {
	415	my ($class) = @_;
	416
	417	my $conf_file = "/etc/frr/frr.conf";
659c27c2 AD	418	my $bin_path = "/usr/lib/frr/frr-reload.py";
	419
	420	if (!-e $bin_path) {
	421	warn "missing $bin_path. Please install frr-pythontools package";
	422	return;
	423	}
fa609bdd AD	424
	425	my $err = sub {
	426	my $line = shift;
659c27c2 AD	427	if ($line =~ /ERROR:/) {
659c27c2 AD	428	warn "$line \n";
fa609bdd AD	429	}
	430	};
	431
	432	if (-e $conf_file && -e $bin_path) {
cdf2c819	433	run_command([$bin_path, '--stdout', '--reload', $conf_file], outfunc => {}, errfunc => $err);
fa609bdd AD	434	}
	435	}
	436
8fb1ee7f	437	1;
32602a38	438
0589eb09	439