def build_l2_evpn_interface_config(self, interfaces_config, interfaces, vn, vlan_conf):
        ifd_map = {}
        for interface in interfaces:
            ifd_map.setdefault(interface.ifd_name, []).append(interface)

        for ifd_name, interface_list in ifd_map.items():
            intf = Interface(name=ifd_name)
            interfaces_config.add_interface(intf)
            intf.set_flexible_vlan_tagging('')
            intf.set_encapsulation("extended-vlan-bridge")
            if interface_list[0].is_untagged():
                if (len(interface_list) > 1):
                    self._logger.error(
                        "invalid logical interfaces config for ifd %s" % (
                            ifd_name))
                    continue
                intf.add_unit(Unit(name=interface_list[0].unit,
                                   comment=DMUtils.l2_evpn_intf_unit_comment(vn, False),
                                   vlan_id="4094"))
                vlan_conf.add_interface(Interface(name=ifd_name + ".0"))
            else:
                for interface in interface_list:
                    intf.add_unit(Unit(name=interface.unit,
                               comment=DMUtils.l2_evpn_intf_unit_comment(vn,
                                                     True, interface.vlan_tag),
                               vlan_id=str(interface.vlan_tag)))
                    vlan_conf.add_interface(Interface(name=ifd_name + "." + str(interface.vlan_tag)))
    def add_inet_public_vrf_filter(self, forwarding_options_config, firewall_config, inet_type):
        fo = Family()
        inet_filter = InetFilter(input=DMUtils.make_public_vrf_filter_name(inet_type))
        if inet_type == "inet6":
            fo.set_inet6(FamilyInet6(filter=inet_filter))
        else:
            fo.set_inet(FamilyInet(filter=inet_filter))
        forwarding_options_config.add_family(fo)

        f = FirewallFilter(name=DMUtils.make_public_vrf_filter_name(inet_type))
        ff = firewall_config.get_family()
        if not ff:
            ff = FirewallFamily()
            firewall_config.set_family(ff)
        if inet_type == "inet6":
            inet6 = ff.get_inet6()
            if not inet6:
                inet6 = FirewallInet()
                ff.set_inet6(inet6)
            inet6.add_filter(f)
        else:
            inet = ff.get_inet()
            if not inet:
                inet = FirewallInet()
                ff.set_inet(inet)
            inet.add_filter(f)

        term = Term(name="default-term", then=Then(accept=""))
        f.add_term(term)
        return f
Esempio n. 3
0
 def set_route_targets_config(self):
     if self.policy_config is None:
         self.policy_config = PolicyOptions(comment=DMUtils.policy_options_comment())
     for route_target in self.route_targets:
         comm = CommunityType(name=DMUtils.make_community_name(route_target))
         comm.add_members(route_target)
         self.policy_config.add_community(comm)
    def _build_ri_config(self, vn, ri_name, ri_obj, interfaces, export_targets,
            import_targets, feature_config):
        encapsulation_priorities = self._get_encapsulation_priorities()
        highest_encapsulation = encapsulation_priorities[0]
        network_id = vn.vn_network_id
        vxlan_id = vn.get_vxlan_vni()

        ri = RoutingInstance(name=ri_name, virtual_network_mode='l2',
            export_targets=export_targets, import_targets=import_targets,
            virtual_network_id=str(network_id), vxlan_id=str(vxlan_id),
            is_public_network=vn.router_external)

        ri.set_virtual_network_id(str(network_id))
        ri.set_vxlan_id(str(vxlan_id))
        ri.set_is_public_network(vn.router_external)

        vlan = None
        if highest_encapsulation == 'VXLAN':
            ri.set_routing_instance_type('virtual-switch')
            vlan = Vlan(name=DMUtils.make_bridge_name(vxlan_id), vxlan_id=vxlan_id)
            vlan.set_comment(DMUtils.vn_bd_comment(vn, 'VXLAN'))
            feature_config.add_vlans(vlan)
            for interface in interfaces:
                self._add_ref_to_list(vlan.get_interfaces(), interface.li_name)
        elif highest_encapsulation in ['MPLSoGRE', 'MPLSoUDP']:
            ri.set_routing_instance_type('evpn')

        self._build_l2_evpn_interface_config(interfaces, vn, vlan)

        return ri
Esempio n. 5
0
    def build_l2_evpn_interface_config(self, interfaces_config, interfaces, vn=None):
        ifd_map = {}
        for interface in interfaces:
            ifd_map.setdefault(interface.ifd_name, []).append(interface)

        for ifd_name, interface_list in ifd_map.items():
            intf = Interface(name=ifd_name)
            interfaces_config.add_interface(intf)
            if interface_list[0].is_untagged():
                if (len(interface_list) > 1):
                    self._logger.error(
                        "invalid logical interfaces config for ifd %s" % (
                            ifd_name))
                    continue
                intf.set_encapsulation("ethernet-bridge")
                intf.add_unit(Unit(name=interface_list[0].unit,
                                   comment=DMUtils.l2_evpn_intf_unit_comment(vn, False),
                                   family=Family(bridge='')))
            else:
                intf.set_flexible_vlan_tagging('')
                intf.set_encapsulation("flexible-ethernet-services")
                for interface in interface_list:
                    intf.add_unit(Unit(name=interface.unit,
                               comment=DMUtils.l2_evpn_intf_unit_comment(vn,
                                                     True, interface.vlan_tag),
                               encapsulation='vlan-bridge',
                               vlan_id=str(interface.vlan_tag)))
 def build_ae_config(self, esi_map):
     if esi_map:
         self.set_chassis_config()
     interfaces_config = self.interfaces_config or \
                 Interfaces(comment=DMUtils.interfaces_comment())
     # self.ae_id_map should have all esi => ae_id mapping
     # esi_map should have esi => interface memberships
     for esi, ae_id in self.physical_router.ae_id_map.items():
         # config ae interface
         ae_name = "ae" + str(ae_id)
         intf = Interface(name=ae_name)
         interfaces_config.add_interface(intf)
         priority = DMUtils.lacp_system_priority()
         system_id = esi[-17:] #last 17 charcaters from esi for ex: 00:00:00:00:00:05
         lacp = Lacp(active='', system_priority=priority, \
                       system_id=system_id, admin_key=1)
         intf.set_aggregated_ether_options(AggregatedEtherOptions(lacp=lacp))
         # associate 'ae' membership
         pi_list = esi_map.get(esi)
         for pi in pi_list or []:
             intf = Interface(name=pi.name)
             interfaces_config.add_interface(intf)
             etherOptions = EtherOptions(ieee_802_3ad=Ieee802(bundle=ae_name))
             intf.set_gigether_options(etherOptions)
     self.interfaces_config = interfaces_config
 def add_inet_public_vrf_filter(self, firewall_config, inet_type):
     firewall_config.set_family(inet_type)
     f = FirewallFilter(name=DMUtils.make_public_vrf_filter_name(inet_type))
     f.set_comment(DMUtils.public_vrf_filter_comment())
     firewall_config.add_firewall_filters(f)
     term = Term(name="default-term", then=Then(accept_or_reject=True))
     f.add_terms(term)
     return f
 def add_inet_vrf_filter(self, firewall_config, vrf_name):
     firewall_config.set_family("inet")
     f = FirewallFilter(name=DMUtils.make_private_vrf_filter_name(vrf_name))
     f.set_comment(DMUtils.vrf_filter_comment(vrf_name))
     firewall_config.add_firewall_filters(f)
     term = Term(name="default-term", then=Then(accept_or_reject=True))
     f.add_terms(term)
     return f
Esempio n. 9
0
    def build_underlay_bgp(self):
        if self.physical_router.allocated_asn is None:
            self._logger.error("physical router %s(%s) does not have asn"
                               " allocated" % (self.physical_router.name,
                                               self.physical_router.uuid))
            return

        for pi_obj, li_obj, iip_obj in self.\
                fetch_pi_li_iip(self.physical_router.physical_interfaces):
            if pi_obj and li_obj and iip_obj and iip_obj.instance_ip_address:
                pi, li_map = self.set_default_pi(pi_obj.name, 'regular')
                pi.set_comment(DMUtils.ip_clos_comment())

                li = self.set_default_li(li_map, li_obj.name,
                                         int(li_obj.name.split('.')[-1]))
                li.set_comment(DMUtils.ip_clos_comment())

                self.add_ip_address(li, iip_obj.instance_ip_address)

                self._logger.debug("looking for peers for physical"
                                   " interface %s(%s)" % (pi_obj.name,
                                                          pi_obj.uuid))
                # Add this bgp object only if it has a peer
                underlay_asn = self.physical_router.allocated_asn
                bgp_name = DMUtils.make_underlay_bgp_group_name(underlay_asn,
                    li_obj.name, is_external=True)
                bgp = Bgp(name=bgp_name,
                          ip_address=iip_obj.instance_ip_address,
                          autonomous_system=underlay_asn,
                          type_='external',
                          comment=DMUtils.ip_clos_comment())
                peers = {}
                # Assumption: PIs are connected for IP-CLOS peering only
                for peer_pi_obj, peer_li_obj, peer_iip_obj in\
                        self.fetch_pi_li_iip(pi_obj.physical_interfaces):
                    if peer_pi_obj and peer_li_obj and peer_iip_obj and\
                            peer_iip_obj.instance_ip_address:

                        peer_pr = PhysicalRouterDM.get(
                            peer_pi_obj.physical_router)
                        if peer_pr is None:
                            self._logger.error(
                                "unable to read peer physical router %s"
                                % peer_pi_obj.physical_router)
                        elif peer_pr.allocated_asn is None:
                            self._logger.error(
                                "peer physical router %s does not have"
                                " asn allocated" % peer_pi_obj.physical_router)
                        elif peer_pr != self.physical_router:
                            peer = Bgp(name=peer_pr.name,
                                       ip_address=peer_iip_obj.instance_ip_address,
                                       autonomous_system=peer_pr.allocated_asn,
                                       comment=peer_pr.name)
                            peers[peer_pr.name] = peer

                if peers:
                    bgp.set_peers(self.get_values_sorted_by_key(peers))
                    self.bgp_map[bgp_name] = bgp
Esempio n. 10
0
 def init_global_switch_opts(self):
     if self.global_switch_options_config is None:
         self.global_switch_options_config = SwitchOptions(comment=DMUtils.switch_options_comment())
     self.global_switch_options_config.set_vtep_source_interface("lo0.0")
     if not self.routing_instances:
         # no vn config then no need to configure vrf target
         return
     self.global_switch_options_config.add_vrf_target(VniTarget(auto=''))
     switch_options_community = DMUtils.get_switch_vrf_import(self.get_asn())
     self.global_switch_options_config.add_vrf_target(VniTarget(community=switch_options_community))
Esempio n. 11
0
 def set_route_targets_config(self):
     if self.policy_config is None:
         self.policy_config = PolicyOptions(comment=DMUtils.policy_options_comment())
     for route_target in self.route_targets:
         comm = CommunityType(name=DMUtils.make_community_name(route_target),
                              members=route_target)
         self.policy_config.add_community(comm)
     # add community for switch options
     comm = CommunityType(name=DMUtils.get_switch_policy_name(),
                              members=DMUtils.get_switch_vrf_import(self.get_asn()))
     self.policy_config.add_community(comm)
Esempio n. 12
0
 def add_lo0_unit_0_interface(self, loopback_ip=''):
     if not loopback_ip:
         return
     if not self.interfaces_config:
         self.interfaces_config = Interfaces(comment=DMUtils.interfaces_comment())
     lo_intf = Interface(name="lo0")
     self.interfaces_config.add_interface(lo_intf)
     fam_inet = FamilyInet(address=[Address(name=loopback_ip + "/32",
                                                primary='', preferred='')])
     intf_unit = Unit(name="0", family=Family(inet=fam_inet),
                          comment=DMUtils.lo0_unit_0_comment())
     lo_intf.add_unit(intf_unit)
    def add_inet_filter_term(self, ri_name, prefixes, inet_type):
        if inet_type == "inet6":
            prefixes = DMUtils.get_ipv6_prefixes(prefixes)
        else:
            prefixes = DMUtils.get_ipv4_prefixes(prefixes)

        from_ = From()
        for prefix in prefixes:
            from_.add_destination_address(prefix)
        then_ = Then()
        then_.add_routing_instance(ri_name)
        return Term(name=DMUtils.make_vrf_term_name(ri_name), fromxx=from_, then=then_)
    def build_firewall_filters(self, sg, acl, is_egress=False):
        acl_rule_present = False
        if not sg or not acl or not acl.vnc_obj:
            return
        acl = acl.vnc_obj
        entries = acl.get_access_control_list_entries()
        if not entries:
            return
        rules = entries.get_acl_rule() or []
        if not rules:
            return
        self.firewall_config = self.firewall_config or\
                               Firewall(DMUtils.firewall_comment())
        for rule in rules:
            if not self.has_terms(rule):
                continue
            match = rule.get_match_condition()
            if not match:
                continue
            acl_rule_present = True
            break

        if acl_rule_present:
            filter_name = DMUtils.make_sg_firewall_name(sg.name, acl.uuid)
            f = FirewallFilter(name=filter_name)
            f.set_comment(DMUtils.make_sg_firewall_comment(sg.name, acl.uuid))
            # allow arp ether type always
            self.add_ether_type_term(f, 'arp')
            # allow dhcp/dns always
            self.add_dns_dhcp_terms(f)
            for rule in rules:
                if not self.has_terms(rule):
                    continue
                match = rule.get_match_condition()
                if not match:
                    continue
                rule_uuid = rule.get_rule_uuid()
                dst_addr_match = match.get_dst_address()
                dst_port_match = match.get_dst_port()
                ether_type_match = match.get_ethertype()
                protocol_match = match.get_protocol()
                src_addr_match = match.get_src_address()
                src_port_match = match.get_src_port()
                term = self.add_filter_term(f, rule_uuid)
                self.add_addr_term(term, dst_addr_match, False)
                self.add_addr_term(term, src_addr_match, True)
                self.add_port_term(term, dst_port_match, False)
                # source port match is not needed for now (BMS source port)
                #self.add_port_term(term, src_port_match, True)
                self.add_protocol_term(term, protocol_match)
            self.firewall_config.add_firewall_filters(f)
    def add_inet_filter_term(self, ri_name, prefixes, inet_type):
        term = etree.Element("term")
        etree.SubElement(term, "name").text = DMUtils.make_vrf_term_name(ri_name)
        from_ = etree.SubElement(term, "from")
        if inet_type == 'inet6':
            prefixes = DMUtils.get_ipv6_prefixes(prefixes)
        else:
            prefixes = DMUtils.get_ipv4_prefixes(prefixes)

        for prefix in prefixes:
            etree.SubElement(from_, "destination-address").text = prefix

        then_ = etree.SubElement(term, "then")
        etree.SubElement(then_, "routing-instance").text = ri_name
        return term
 def add_inet_public_vrf_filter(self, forwarding_options_config,
                                      firewall_config, inet_type, inet_xml_name):
     fo = etree.SubElement(forwarding_options_config, "family")
     inet = etree.SubElement(fo, inet_xml_name)
     f = etree.SubElement(inet, "filter")
     etree.SubElement(f, "input").text = DMUtils.make_public_vrf_filter_name(inet_type)
     fc = etree.SubElement(firewall_config, "family")
     inet = etree.SubElement(fc, inet_xml_name)
     f = etree.SubElement(inet, "filter")
     etree.SubElement(f, "name").text = DMUtils.make_public_vrf_filter_name(inet_type)
     term = etree.SubElement(f, "term")
     etree.SubElement(term, "name").text = "default-term"
     then_ = etree.SubElement(term, "then")
     etree.SubElement(then_, "accept")
     return f
 def _get_bgp_config_xml(self, external=False):
     if self.bgp_params is None:
         return None
     bgp_group = BgpGroup()
     if external:
         bgp_group.set_name(DMUtils.make_bgp_group_name(True))
         bgp_group.set_type("external")
         bgp_group.set_multihop("")
     else:
         bgp_group.set_name(DMUtils.make_bgp_group_name(False))
         bgp_group.set_type("internal")
     bgp_group.set_local_address(self.bgp_params["address"])
     self.add_families(bgp_group, self.bgp_params)
     self.add_bgp_auth_config(bgp_group, self.bgp_params)
     self.add_bgp_hold_time_config(bgp_group, self.bgp_params)
     return bgp_group
Esempio n. 18
0
 def add_pnf_logical_interface(self, junos_interface):
     if not self.interfaces_config:
         self.interfaces_config = Interfaces(comment=DMUtils.interfaces_comment())
     family = Family(inet=FamilyInet([Address(name=junos_interface.ip)]))
     unit = Unit(name=junos_interface.unit, vlan_id=junos_interface.vlan_tag, family=family)
     interface = Interface(name=junos_interface.ifd_name, unit=unit)
     self.interfaces_config.add_interface(interface)
    def get_firewall_filters(self, sg, acl, is_egress=False):
        acl_rule_present = False
        if not sg or not acl or not acl.vnc_obj:
            return []
        acl = acl.vnc_obj
        entries = acl.get_access_control_list_entries()
        if not entries:
            return []
        rules = entries.get_acl_rule() or []
        if not rules:
            return []
        filter_names = []
        for rule in rules:
            if not self.has_terms(rule):
                continue
            match = rule.get_match_condition()
            if not match:
                continue
            rule_uuid = rule.get_rule_uuid()
            ether_type_match = match.get_ethertype()
            if not ether_type_match:
                continue
            if 'ipv6' in ether_type_match.lower():
                continue
            acl_rule_present = True
            break

        if acl_rule_present:
            filter_name = DMUtils.make_sg_firewall_name(sg.name, acl.uuid)
            filter_names.append(filter_name)
        return filter_names
Esempio n. 20
0
 def set_as_config(self):
     if not self.bgp_params.get("identifier"):
         return
     if self.global_routing_options_config is None:
         self.global_routing_options_config = RoutingOptions(comment=DMUtils.routing_options_comment())
     self.global_routing_options_config.set_route_distinguisher_id(self.bgp_params['identifier'])
     self.global_routing_options_config.set_autonomous_system(str(self.get_asn()))
    def _build_ri_config(self, vn, ri_name, ri_obj, export_targets,
            import_targets, feature_config, irb_ips):
        encapsulation_priorities = self._get_encapsulation_priorities()
        network_id = vn.vn_network_id
        vxlan_id = vn.get_vxlan_vni()

        ri = RoutingInstance(name=ri_name, virtual_network_mode='l3',
            export_targets=export_targets, import_targets=import_targets,
            virtual_network_id=str(network_id), vxlan_id=str(vxlan_id),
            is_public_network=vn.router_external, routing_instance_type='vrf')

        for prefix in vn.get_prefixes():
            ri.add_prefixes(self._get_subnet_for_cidr(prefix))

        _, li_map = self._add_or_lookup_pi(self.pi_map, 'irb', 'irb')
        if irb_ips:
            irb = self._add_or_lookup_li(li_map, 'irb.'+str(network_id),
                                         network_id)
            for (irb_ip, gateway) in irb_ips:
                self._add_ip_address(irb, irb_ip, gateway=gateway)
        vlan = Vlan(name=DMUtils.make_bridge_name(vxlan_id), vxlan_id=vxlan_id)
        feature_config.add_vlans(vlan)
        self._add_ref_to_list(vlan.get_interfaces(), irb.get_name())

        return ri
Esempio n. 22
0
 def set_route_distinguisher_config(self):
     if not self.routing_instances:
         # no vn config then no need to configure route distinguisher
         return
     if self.global_switch_options_config is None:
         self.global_switch_options_config = SwitchOptions(comment=DMUtils.switch_options_comment())
     self.global_switch_options_config.set_route_distinguisher(
                              RouteDistinguisher(rd_type=self.bgp_params['identifier'] + ":1"))
 def _get_bgp_config_xml(self, external=False):
     if self.bgp_params is None:
         return None
     bgp_config = etree.Element("group", operation="replace")
     if external:
         etree.SubElement(bgp_config, "name").text = DMUtils.make_bgp_group_name(True)
         etree.SubElement(bgp_config, "type").text = "external"
         etree.SubElement(bgp_config, "multihop")
     else:
         etree.SubElement(bgp_config, "name").text = DMUtils.make_bgp_group_name(False)
         etree.SubElement(bgp_config, "type").text = "internal"
     local_address = etree.SubElement(bgp_config, "local-address")
     local_address.text = self.bgp_params['address']
     self._add_family_etree(bgp_config, self.bgp_params)
     self.add_bgp_auth_config(bgp_config, self.bgp_params)
     self.add_bgp_hold_time_config(bgp_config, self.bgp_params)
     return bgp_config
 def add_bogus_lo0(self, ri, network_id, vn):
     ifl_num = 1000 + int(network_id)
     lo_intf, li_map = self.set_default_pi('lo0', 'loopback')
     intf_name = 'lo0.' + str(ifl_num)
     intf_unit = self.set_default_li(li_map, intf_name, ifl_num)
     intf_unit.set_comment(DMUtils.l3_bogus_lo_intf_comment(vn))
     self.add_ip_address(intf_unit, "127.0.0.1")
     self.add_ref_to_list(ri.get_loopback_interfaces(), intf_name)
Esempio n. 25
0
 def _get_bgp_config_xml(self, external=False):
     if self.bgp_params is None or not self.bgp_params.get('address'):
         return None
     bgp_group = BgpGroup()
     bgp_group.set_comment(DMUtils.bgp_group_comment(self.bgp_obj))
     if external:
         bgp_group.set_name(DMUtils.make_bgp_group_name(self.get_asn(), True))
         bgp_group.set_type('external')
         bgp_group.set_multihop('')
     else:
         bgp_group.set_name(DMUtils.make_bgp_group_name(self.get_asn(), False))
         bgp_group.set_type('internal')
         self.add_ibgp_export_policy(self.bgp_params, bgp_group)
     bgp_group.set_local_address(self.bgp_params['address'])
     self.add_families(bgp_group, self.bgp_params)
     self.add_bgp_auth_config(bgp_group, self.bgp_params)
     self.add_bgp_hold_time_config(bgp_group, self.bgp_params)
     return bgp_group
    def _build_underlay_bgp(self, feature_config):
        if self._physical_router.allocated_asn is None:
            self._logger.error("physical router %s(%s) does not have asn"
                               " allocated" % (self._physical_router.name,
                                               self._physical_router.uuid))
            return

        pi_map = OrderedDict()
        for pi_obj, li_obj, iip_obj in self.\
                _fetch_pi_li_iip(self._physical_router.physical_interfaces):
            if pi_obj and li_obj and iip_obj and iip_obj.instance_ip_address:
                pi, li_map = self._add_or_lookup_pi(pi_map, pi_obj.name, 'regular')

                li = self._add_or_lookup_li(li_map, li_obj.name,
                                            int(li_obj.name.split('.')[-1]))

                self._add_ip_address(li, iip_obj.instance_ip_address)

                self._logger.debug("looking for peers for physical"
                                   " interface %s(%s)" % (pi_obj.name,
                                                          pi_obj.uuid))
                # Add this bgp object only if it has a peer
                underlay_asn = self._physical_router.allocated_asn
                bgp_name = DMUtils.make_underlay_bgp_group_name(underlay_asn,
                    li_obj.name, is_external=True)
                bgp = Bgp(name=bgp_name,
                          ip_address=iip_obj.instance_ip_address,
                          autonomous_system=underlay_asn,
                          type_='external')
                peers = OrderedDict()
                # Assumption: PIs are connected for IP-CLOS peering only
                for peer_pi_obj, peer_li_obj, peer_iip_obj in\
                        self._fetch_pi_li_iip(pi_obj.physical_interfaces):
                    if peer_pi_obj and peer_li_obj and peer_iip_obj and\
                            peer_iip_obj.instance_ip_address:

                        peer_pr = db.PhysicalRouterDM.get(
                            peer_pi_obj.physical_router)
                        if peer_pr is None:
                            self._logger.error(
                                "unable to read peer physical router %s"
                                % peer_pi_obj.physical_router)
                        elif peer_pr.allocated_asn is None:
                            self._logger.error(
                                "peer physical router %s does not have"
                                " asn allocated" % peer_pi_obj.physical_router)
                        elif peer_pr != self._physical_router:
                            peer = Bgp(name=peer_pr.name,
                                       ip_address=peer_iip_obj.instance_ip_address,
                                       autonomous_system=peer_pr.allocated_asn)
                            peers[peer_pr.name] = peer

                if peers:
                    bgp.set_peers(peers.values())
                    feature_config.add_bgp(bgp)
Esempio n. 27
0
 def get_bgp_config(self, external=False):
     if self.bgp_params is None or not self.bgp_params.get('address'):
         return None
     bgp = Bgp()
     cluster_id = self.bgp_params.get('cluster_id')
     if cluster_id:
         bgp.set_cluster_id(cluster_id)
     bgp.set_comment(DMUtils.bgp_group_comment(self.bgp_obj))
     if external:
         bgp.set_name(DMUtils.make_bgp_group_name(self.get_asn(), True))
         bgp.set_type('external')
     else:
         bgp.set_name(DMUtils.make_bgp_group_name(self.get_asn(), False))
         bgp.set_type('internal')
     bgp.set_ip_address(self.bgp_params['address'])
     bgp.set_autonomous_system(self.get_asn())
     self.add_families(bgp, self.bgp_params)
     self.add_bgp_auth_config(bgp, self.bgp_params)
     self.add_bgp_hold_time_config(bgp, self.bgp_params)
     return bgp
Esempio n. 28
0
 def add_vlan_config(self, vrf_name, vni, is_l3=False, irb_intf=None):
     if not self.vlans_config:
         self.vlans_config = Vlans(comment=DMUtils.vlans_comment())
     vxlan = VXLan(vni=vni)
     vlan = Vlan(name=vrf_name[1:], vxlan=vxlan)
     if is_l3:
         if not irb_intf:
             self._logger.error("Missing irb interface config l3 vlan: %s" % vrf_name)
         else:
             vlan.set_l3_interface(irb_intf)
     self.vlans_config.add_vlan(vlan)
     return vlan
Esempio n. 29
0
    def add_dynamic_tunnels(self, tunnel_source_ip,
                             ip_fabric_nets, bgp_router_ips):
        dynamic_tunnel = DynamicTunnel(name=DMUtils.dynamic_tunnel_name(self.get_asn()),
                                       source_address=tunnel_source_ip, gre='')
        if ip_fabric_nets is not None:
            for subnet in ip_fabric_nets.get("subnet", []):
                dest_net = subnet['ip_prefix'] + '/' + str(subnet['ip_prefix_len'])
                dynamic_tunnel.add_destination_networks(
                    DestinationNetworks(name=dest_net,
                                        comment=DMUtils.ip_fabric_subnet_comment()))

        for r_name, bgp_router_ip in bgp_router_ips.items():
            dynamic_tunnel.add_destination_networks(
                DestinationNetworks(name=bgp_router_ip + '/32',
                                    comment=DMUtils.bgp_router_subnet_comment(r_name)))

        dynamic_tunnels = DynamicTunnels()
        dynamic_tunnels.add_dynamic_tunnel(dynamic_tunnel)
        if self.global_routing_options_config is None:
            self.global_routing_options_config = RoutingOptions(comment=DMUtils.routing_options_comment())
        self.global_routing_options_config.set_dynamic_tunnels(dynamic_tunnels)
Esempio n. 30
0
 def add_ibgp_export_policy(self, params, bgp_group):
     if params.get('address_families') is None:
         return
     families = params['address_families'].get('family', [])
     if not families:
         return
     if self.policy_config is None:
         self.policy_config = PolicyOptions(comment=DMUtils.policy_options_comment())
     ps = PolicyStatement(name=DMUtils.make_ibgp_export_policy_name())
     self.policy_config.add_policy_statement(ps)
     ps.set_comment(DMUtils.ibgp_export_policy_comment())
     vpn_types = []
     for family in ['inet-vpn', 'inet6-vpn']:
         if family in families:
             vpn_types.append(family)
     for vpn_type in vpn_types:
         is_v6 = True if vpn_type == 'inet6-vpn' else False
         term = Term(name=DMUtils.make_ibgp_export_policy_term_name(is_v6))
         ps.add_term(term)
         then = Then()
         from_ = From()
         term.set_from(from_)
         term.set_then(then)
         from_.set_family(DMUtils.get_inet_family_name(is_v6))
         then.set_next_hop(NextHop(selfxx=''))
     bgp_group.set_export(DMUtils.make_ibgp_export_policy_name())
Esempio n. 31
0
 def prepare_groups(self, is_delete=False):
     groups = Groups()
     if is_delete:
         return groups
     groups.set_comment(DMUtils.groups_comment())
     groups.set_routing_instances(self.ri_config)
     groups.set_interfaces(self.interfaces_config)
     groups.set_services(self.services_config)
     groups.set_policy_options(self.policy_config)
     groups.set_firewall(self.firewall_config)
     groups.set_forwarding_options(self.forwarding_options_config)
     groups.set_routing_options(self.global_routing_options_config)
     groups.set_protocols(self.proto_config)
     self.add_product_specific_config(groups)
     return groups
Esempio n. 32
0
 def set_internal_vn_irb_config(self):
     if self.internal_vn_ris and self.irb_interfaces:
         for int_ri in self.internal_vn_ris:
             lr_uuid = DMUtils.extract_lr_uuid_from_internal_vn_name(
                 int_ri.name)
             lr = LogicalRouterDM.get(lr_uuid)
             if not lr:
                 continue
             vn_list = lr.get_connected_networks(include_internal=False)
             for vn in vn_list:
                 vn_obj = VirtualNetworkDM.get(vn)
                 irb_name = "irb." + str(vn_obj.vn_network_id)
                 if irb_name in self.irb_interfaces:
                     int_ri.add_routing_interfaces(
                         LogicalInterface(name=irb_name))
Esempio n. 33
0
 def set_bgp_group_config(self):
     bgp_config = self._get_bgp_config_xml()
     if not bgp_config:
         return
     if not self.proto_config:
         self.proto_config = Protocols(comment=DMUtils.protocols_comment())
     bgp = Bgp()
     self.proto_config.set_bgp(bgp)
     bgp.add_group(bgp_config)
     self._get_neighbor_config_xml(bgp_config, self.bgp_peers)
     if self.external_peers:
         ext_grp_config = self._get_bgp_config_xml(True)
         bgp.add_group(ext_grp_config)
         self._get_neighbor_config_xml(ext_grp_config, self.external_peers)
     return
 def add_bogus_lo0(self, ri, network_id, vn):
     if not self.is_spine():
         return
     self.interfaces_config = self.interfaces_config or []
     ifl_num = 1000 + int(network_id)
     lo_intf = PhysicalInterface(name="lo0", interface_type='loopback')
     self.interfaces_config.append(lo_intf)
     intf_unit = LogicalInterface(
         name="lo0." + str(ifl_num),
         unit=ifl_num,
         comment=DMUtils.l3_bogus_lo_intf_comment(vn))
     intf_unit.add_ip_list(IpType(address="127.0.0.1"))
     lo_intf.add_logical_interfaces(intf_unit)
     ri.add_loopback_interfaces(LogicalInterface(name="lo0." +
                                                 str(ifl_num)))
 def set_dci_vn_irb_config(self):
     if self.dci_vn_ris and self.irb_interfaces:
         for int_ri in self.dci_vn_ris:
             dci_uuid = DMUtils.extract_dci_uuid_from_internal_vn_name(
                 int_ri.name)
             dci = DataCenterInterconnectDM.get(dci_uuid)
             if not dci or not dci.virtual_network:
                 continue
             vn = dci.virtual_network
             vn_obj = VirtualNetworkDM.get(vn)
             if vn_obj is None or vn_obj.vn_network_id is None:
                 continue
             irb_name = "irb." + str(vn_obj.vn_network_id)
             if irb_name in self.irb_interfaces:
                 self.add_ref_to_list(int_ri.get_routing_interfaces(),
                                      irb_name)
Esempio n. 36
0
 def add_irb_config(self, ri_conf):
     vn = ri_conf.get("vn")
     is_l2_l3 = ri_conf.get("is_l2_l3", False)
     gateways = ri_conf.get("gateways", [])
     network_id = ri_conf.get("network_id", None)
     irb_intf, li_map = self.set_default_pi('irb', 'irb')
     self._logger.info("Vn=" + vn.name + ", IRB: " + str(gateways) +
                       ", pr=" + self.physical_router.name)
     if gateways is not None:
         intf_unit = self.set_default_li(li_map, 'irb.' + str(network_id),
                                         network_id)
         intf_unit.set_comment(DMUtils.vn_irb_comment(vn, False, is_l2_l3))
         for (irb_ip, gateway) in gateways:
             intf_unit.add_ip_list(irb_ip)
             if len(gateway) and gateway != '0.0.0.0':
                 intf_unit.set_gateway(gateway)
    def add_dynamic_tunnels(self, tunnel_source_ip,
                            ip_fabric_nets, bgp_router_ips):
        if not self.system_config:
            self.system_config = System()
        self.system_config.set_tunnel_ip(tunnel_source_ip)
        dynamic_tunnel = DynamicTunnel(
            name=DMUtils.dynamic_tunnel_name(self.get_asn()),
            source_address=tunnel_source_ip, gre='')
        if ip_fabric_nets is not None:
            for subnet in ip_fabric_nets.get("subnet", []):
                dest_net = Subnet(prefix=subnet['ip_prefix'],
                                  prefix_len=subnet['ip_prefix_len'])
                self.system_config.add_tunnel_destination_networks(dest_net)

        for r_name, bgp_router_ip in bgp_router_ips.items():
            dest_net = Subnet(prefix=bgp_router_ip, prefix_len=32)
            self.system_config.add_tunnel_destination_networks(dest_net)
    def build_dci_bgp_config(self):
        if not self.physical_router.has_rb_role("DCI-Gateway"):
            return
        self.physical_router.evaluate_dci_ip_map()
        dci_list = self.physical_router.get_dci_list()
        for dci_uuid in dci_list or []:
            params = self.physical_router.get_dci_bgp_params(dci_uuid)
            if not params:
                continue
            asn = params.get("asn")
            ip = params.get("ip")
            name = params.get("name")
            typ = params.get("type")
            bgp = Bgp(name=name,
                      ip_address=ip,
                      autonomous_system=asn,
                      type_=typ)
            bgp.set_comment(DMUtils.dci_bgp_group_comment(bgp))
            bgp.set_hold_time(params.get('hold_time'))
            for family in params.get("families") or []:
                if family in ['e-vpn', 'e_vpn']:
                    family = 'evpn'
                bgp.add_families(family)

            bgp_name = name
            neigh_list = self.physical_router.get_dci_bgp_neighbours(dci_uuid)
            peers = {}
            for neigh in neigh_list or []:
                asn = neigh.get("asn")
                ip = neigh.get("ip")
                name = neigh.get("name")
                typ = neigh.get("type")
                peer = Bgp(name=name,
                           ip_address=ip,
                           autonomous_system=asn,
                           type_=typ)
                peers[name] = peer
                peer.set_hold_time(neigh.get('hold_time'))
                for family in neigh.get("families") or []:
                    if family in ['e-vpn', 'e_vpn']:
                        family = 'evpn'
                    peer.add_families(family)

            if peers:
                bgp.set_peers(self.get_values_sorted_by_key(peers))
                self.bgp_map[bgp_name] = bgp
Esempio n. 39
0
    def _build_l2_evpn_interface_config(self, interfaces, vn, vlan):
        interface_map = OrderedDict()
        for interface in interfaces:
            interface_map.setdefault(interface.pi_name, []).append(interface)

        for pi_name, interface_list in interface_map.items():
            untagged = [int(i.port_vlan_tag) for i in interface_list
                        if int(i.vlan_tag) == 0]
            if len(untagged) > 1:
                self._logger.error(
                    "Only one untagged interface is allowed on a PI %s" %
                    pi_name)
                continue
            tagged = [int(i.vlan_tag) for i in interface_list
                      if int(i.vlan_tag) != 0]
            if self._is_enterprise_style(self._physical_router):
                if len(untagged) > 0 and len(tagged) > 0:
                    self._logger.error(
                        "Enterprise style config: Can't have tagged and "
                        "untagged interfaces for same VN on same PI %s" %
                        pi_name)
                    continue
            elif len(set(untagged) & set(tagged)) > 0:
                self._logger.error(
                    "SP style config: Can't have tagged and untagged "
                    "interfaces with same Vlan-id on same PI %s" %
                    pi_name)
                continue
            _, li_map = self._add_or_lookup_pi(self.pi_map, pi_name)
            for interface in interface_list:
                if int(interface.vlan_tag) == 0:
                    is_tagged = False
                    vlan_tag = str(interface.port_vlan_tag)
                else:
                    is_tagged = True
                    vlan_tag = str(interface.vlan_tag)
                unit = self._add_or_lookup_li(li_map, interface.li_name,
                                              interface.unit)
                unit.set_comment(DMUtils.l2_evpn_intf_unit_comment(
                    vn, is_tagged, vlan_tag))
                unit.set_is_tagged(is_tagged)
                unit.set_vlan_tag(vlan_tag)
                if vlan:
                    self._add_ref_to_list(vlan.get_interfaces(),
                                          interface.li_name)
Esempio n. 40
0
    def _get_config(self, bgp, external=False):
        config = Bgp()

        cluster_id = bgp.params.get('cluster_id')
        if cluster_id:
            config.set_cluster_id(cluster_id)

        config.set_name(DMUtils.make_bgp_group_name(self._get_asn(bgp), external))
        config.set_type('external' if external else 'internal')

        config.set_ip_address(bgp.params['address'])
        config.set_autonomous_system(self._get_asn(bgp))

        self._add_families(config, bgp.params)
        self._add_auth_config(config, bgp.params)
        self._add_hold_time_config(config, bgp.params)

        return config
Esempio n. 41
0
 def update(self, obj=None):
     if obj is None:
         obj = self.read_obj(self.uuid)
     self.update_multiple_refs('physical_router', obj)
     self.fq_name = obj['fq_name']
     try:
         self.router_external = obj['router_external']
     except KeyError:
         self.router_external = False
     self.vn_network_id = obj.get('virtual_network_network_id')
     self.virtual_network_properties = obj.get('virtual_network_properties')
     self.set_forwarding_mode(obj)
     self.routing_instances = set([ri['uuid'] for ri in
                                   obj.get('routing_instances', [])])
     self.virtual_machine_interfaces = set(
         [vmi['uuid'] for vmi in
          obj.get('virtual_machine_interface_back_refs', [])])
     self.gateways = DMUtils.get_network_gateways(obj.get('network_ipam_refs', []))
Esempio n. 42
0
    def send_bgp_config(self):
        if not self.set_bgp_group_config():
            return 0

        self.set_as_config()
        self.set_route_targets_config()

        groups = Groups()
        groups.set_comment(DMUtils.groups_comment())
        groups.set_routing_instances(self.ri_config)
        groups.set_interfaces(self.interfaces_config)
        groups.set_services(self.services_config)
        groups.set_policy_options(self.policy_config)
        groups.set_firewall(self.firewall_config)
        groups.set_forwarding_options(self.forwarding_options_config)
        groups.set_routing_options(self.global_routing_options_config)
        groups.set_protocols(self.proto_config)
        return self.send_netconf(groups)
Esempio n. 43
0
 def build_esi_config(self):
     pr = self.physical_router
     if not pr or self.is_spine():
         return
     if not self.interfaces_config:
         self.interfaces_config = Interfaces(comment=DMUtils.interfaces_comment())
     for pi_uuid in pr.physical_interfaces:
         pi = PhysicalInterfaceDM.get(pi_uuid)
         if not pi or not pi.esi or pi.esi == "0" or pi.get_parent_ae_id():
             continue
         esi_conf = Esi(identifier=pi.esi, all_active='')
         intf = Interface(name=pi.name, esi=esi_conf)
         self.interfaces_config.add_interface(intf)
     # add ae interfaces
     # self.ae_id_map should have all esi => ae_id mapping
     for esi, ae_id in self.physical_router.ae_id_map.items():
         esi_conf = Esi(identifier=esi, all_active='')
         intf = Interface(name="ae" + str(ae_id), esi=esi_conf)
         self.interfaces_config.add_interface(intf)
 def add_irb_config(self, ri_conf):
     vn = ri_conf.get("vn")
     is_l2_l3 = ri_conf.get("is_l2_l3", False)
     gateways = ri_conf.get("gateways", [])
     network_id = ri_conf.get("network_id", None)
     self.interfaces_config = self.interfaces_config or []
     irb_intf = PhysicalInterface(name='irb', interface_type='irb')
     self.interfaces_config.append(irb_intf)
     self._logger.info("Vn=" + vn.name + ", IRB: " + str(gateways) +
                       ", pr=" + self.physical_router.name)
     if gateways is not None:
         intf_unit = LogicalInterface(name='irb.' + str(network_id),
                                      unit=network_id,
                                      comment=DMUtils.vn_irb_comment(
                                          vn, False, is_l2_l3))
         irb_intf.add_logical_interfaces(intf_unit)
         for (irb_ip, gateway) in gateways:
             intf_unit.add_ip_list(irb_ip)
             if len(gateway) and gateway != '0.0.0.0':
                 intf_unit.set_gateway(gateway)
Esempio n. 45
0
    def prepare_conf(self, is_delete=False):
        device = Device()
        device.set_comment(DMUtils.groups_comment())
        device.set_system(self.system_config)
        if is_delete:
            return device

        device.set_evpn(self.evpn)
        device.set_bgp(self.get_values_sorted_by_key(self.bgp_map))

        pis = []
        for pi, li_map in self.get_values_sorted_by_key(self.pi_map):
            pi.set_logical_interfaces(self.get_values_sorted_by_key(li_map))
            pis.append(pi)

        device.set_physical_interfaces(pis)
        device.set_routing_instances(self.get_values_sorted_by_key(
            self.ri_map))
        device.set_vlans(self.get_values_sorted_by_key(self.vlan_map))
        device.set_firewall(self.firewall_config)
        return device
 def _get_neighbor_config_xml(self, bgp_config, peers):
     for peer, peer_data in peers.items():
         obj = peer_data.get('obj')
         params = peer_data.get('params', {})
         attr = peer_data.get('attr', {})
         nbr = Bgp(name=peer)
         nbr.set_comment(DMUtils.bgp_group_comment(obj))
         bgp_config.add_peers(nbr)
         bgp_sessions = attr.get('session')
         if bgp_sessions:
             # for now assume only one session
             session_attrs = bgp_sessions[0].get('attributes', [])
             for session_attr in session_attrs:
                 # For not, only consider the attribute if bgp-router is
                 # not specified
                 if session_attr.get('bgp_router') is None:
                     self.add_families(nbr, session_attr)
                     self.add_bgp_auth_config(nbr, session_attr)
                     break
         peer_as = params.get('local_autonomous_system') or params.get('autonomous_system')
         nbr.set_autonomous_system(peer_as)
Esempio n. 47
0
 def update_instance_ip_map(self):
     self.instance_ip_map = {}
     for vmi_uuid in self.virtual_machine_interfaces:
         vmi = VirtualMachineInterfaceDM.get(vmi_uuid)
         if vmi is None or vmi.is_device_owner_bms() == False:
             continue
         if vmi.floating_ip is not None and vmi.instance_ip is not None:
             fip = FloatingIpDM.get(vmi.floating_ip)
             inst_ip = InstanceIpDM.get(vmi.instance_ip)
             if fip is None or inst_ip is None:
                 continue
             instance_ip = inst_ip.instance_ip_address
             floating_ip = fip.floating_ip_address
             public_vn = VirtualNetworkDM.get(fip.public_network)
             if public_vn is None or public_vn.vn_network_id is None:
                 continue
             public_vrf_name = DMUtils.make_vrf_name(
                 public_vn.fq_name[-1], public_vn.vn_network_id, 'l3')
             self.instance_ip_map[instance_ip] = {
                 'floating_ip': floating_ip,
                 'vrf_name': public_vrf_name
             }
 def add_dynamic_tunnels(self, tunnel_source_ip, ip_fabric_nets,
                         bgp_router_ips):
     self.tunnel_config = etree.Element("routing-options")
     dynamic_tunnels = etree.SubElement(self.tunnel_config,
                                        "dynamic-tunnels")
     dynamic_tunnel = etree.SubElement(dynamic_tunnels, "dynamic-tunnel")
     etree.SubElement(dynamic_tunnel,
                      "name").text = DMUtils.get_dynamic_tunnel_name()
     etree.SubElement(dynamic_tunnel,
                      "source-address").text = tunnel_source_ip
     etree.SubElement(dynamic_tunnel, "gre")
     if ip_fabric_nets is not None:
         for subnet in ip_fabric_nets.get("subnet", []):
             dest_network = etree.SubElement(dynamic_tunnel,
                                             "destination-networks")
             etree.SubElement(
                 dest_network,
                 "name").text = subnet['ip_prefix'] + '/' + str(
                     subnet['ip_prefix_len'])
     for bgp_router_ip in bgp_router_ips:
         dest_network = etree.SubElement(dynamic_tunnel,
                                         "destination-networks")
         etree.SubElement(dest_network, "name").text = bgp_router_ip + '/32'
    def feature_config(self, **kwargs):
        self.pi_map = OrderedDict()
        feature_config = Feature(name=self.feature_name())
        vn_map = self._get_interconnect_vn_map()

        for vn_uuid, vn_list in vn_map.iteritems():
            vn_obj = db.VirtualNetworkDM.get(vn_uuid)
            ri_obj = self._get_primary_ri(vn_obj)
            if ri_obj is None:
                continue
            ri_name = DMUtils.make_vrf_name(vn_obj.fq_name[-1],
                                            vn_obj.vn_network_id, 'l3')
            export_targets, import_targets = self._get_export_import_targets(
                vn_obj, ri_obj)
            ri = self._build_ri_config(vn_obj, ri_name, ri_obj, export_targets,
                                       import_targets, feature_config, vn_list)
            feature_config.add_routing_instances(ri)

        for pi, li_map in self.pi_map.values():
            pi.set_logical_interfaces(li_map.values())
            feature_config.add_physical_interfaces(pi)

        return feature_config
 def add_peer_bgp_config(self, bgp_config, peers):
     peer_map = {}
     for peer, peer_data in self.get_sorted_key_value_pairs(peers):
         obj = peer_data.get('obj')
         params = peer_data.get('params', {})
         attr = peer_data.get('attr', {})
         nbr = Bgp(name=peer, ip_address=peer)
         nbr.set_comment(DMUtils.bgp_group_comment(obj))
         peer_map[peer] = nbr
         bgp_sessions = attr.get('session')
         if bgp_sessions:
             # for now assume only one session
             session_attrs = bgp_sessions[0].get('attributes', [])
             for session_attr in session_attrs:
                 # For not, only consider the attribute if bgp-router is
                 # not specified
                 if session_attr.get('bgp_router') is None:
                     self.add_families(nbr, session_attr)
                     self.add_bgp_auth_config(nbr, session_attr)
                     break
         peer_as = params.get('local_autonomous_system') or params.get('autonomous_system')
         nbr.set_autonomous_system(peer_as)
     if peer_map:
         bgp_config.set_peers(self.get_values_sorted_by_key(peer_map))
    def feature_config(self, **kwargs):
        self.pi_map = OrderedDict()
        feature_config = Feature(name=self.feature_name())
        vns = self._get_connected_vn_ids()
        use_gateway_ip = all([c.additional_params.use_gateway_ip == 'True' for c in self._configs])
        irb_ip_map = self._physical_router.allocate_irb_ips_for(vns, use_gateway_ip)

        for vn_uuid in vns:
            vn_obj = db.VirtualNetworkDM.get(vn_uuid)
            ri_obj = self._get_primary_ri(vn_obj)
            if ri_obj is None:
                continue
            ri_name = DMUtils.make_vrf_name(vn_obj.fq_name[-1],
                                            vn_obj.vn_network_id, 'l3')
            export_targets, import_targets = self._get_export_import_targets(vn_obj, ri_obj)
            ri = self._build_ri_config(vn_obj, ri_name, ri_obj, export_targets,
                import_targets, feature_config, irb_ip_map.get(vn_uuid, []))
            feature_config.add_routing_instances(ri)

        for pi, li_map in self.pi_map.values():
            pi.set_logical_interfaces(li_map.values())
            feature_config.add_physical_interfaces(pi)

        return feature_config
    def _build_ri_config(self, vn, ri_name, ri_obj, export_targets,
                         import_targets, feature_config, irb_ips):
        gevent.idle()
        network_id = vn.vn_network_id
        vxlan_id = vn.get_vxlan_vni()

        ri = RoutingInstance(name=ri_name,
                             virtual_network_mode='l3',
                             export_targets=export_targets,
                             import_targets=import_targets,
                             virtual_network_id=str(network_id),
                             vxlan_id=str(vxlan_id),
                             is_public_network=vn.router_external,
                             routing_instance_type='vrf')

        for prefix in vn.get_prefixes(self._physical_router.uuid):
            ri.add_prefixes(self._get_subnet_for_cidr(prefix))

        _, li_map = self._add_or_lookup_pi(self.pi_map, 'irb', 'irb')
        irb = None
        if irb_ips:
            irb = self._add_or_lookup_li(li_map, 'irb.' + str(network_id),
                                         network_id)
            if vn.has_ipv6_subnet is True:
                irb.set_is_virtual_router(True)
            for (irb_ip, gateway) in irb_ips:
                self._add_ip_address(irb, irb_ip, gateway=gateway)

        vlan = Vlan(name=DMUtils.make_bridge_name(vxlan_id), vxlan_id=vxlan_id)
        desc = "Virtual Network - %s" % vn.name
        vlan.set_description(desc)
        feature_config.add_vlans(vlan)
        if irb:
            self._add_ref_to_list(vlan.get_interfaces(), irb.get_name())

        return ri
Esempio n. 53
0
    def add_routing_instance(self, ri_conf):
        ri_name = ri_conf.get("ri_name")
        vn = ri_conf.get("vn")
        is_l2 = ri_conf.get("is_l2", False)
        is_l2_l3 = ri_conf.get("is_l2_l3", False)
        import_targets = ri_conf.get("import_targets", set())
        export_targets = ri_conf.get("export_targets", set())
        prefixes = ri_conf.get("prefixes", [])
        gateways = ri_conf.get("gateways", [])
        interfaces = ri_conf.get("interfaces", [])
        vni = ri_conf.get("vni", None)
        network_id = ri_conf.get("network_id", None)

        self.routing_instances[ri_name] = ri_conf
        ri_config = self.ri_config or RoutingInstances(
            comment=DMUtils.routing_instances_comment())
        policy_config = self.policy_config or PolicyOptions(
            comment=DMUtils.policy_options_comment())
        ri = Instance(name=ri_name)

        ri_config.add_instance(ri)
        ri_opt = None

        # for both l2 and l3
        ri.set_vrf_import(DMUtils.make_import_name(ri_name))
        ri.set_vrf_export(DMUtils.make_export_name(ri_name))

        has_ipv6_prefixes = DMUtils.has_ipv6_prefixes(prefixes)
        has_ipv4_prefixes = DMUtils.has_ipv4_prefixes(prefixes)

        if not is_l2:
            if ri_opt is None:
                ri_opt = RoutingInstanceRoutingOptions()
                ri.set_routing_options(ri_opt)

            ri.set_instance_type("vrf")
            for interface in interfaces:
                ri.add_interface(Interface(name=interface.name))
            family = Family()
            if has_ipv4_prefixes:
                family.set_inet(FamilyInet(unicast=''))
            if has_ipv6_prefixes:
                family.set_inet6(FamilyInet6(unicast=''))
            if has_ipv4_prefixes or has_ipv6_prefixes:
                auto_export = AutoExport(family=family)
                ri_opt.set_auto_export(auto_export)
        else:
            ri.set_instance_type("virtual-switch")

        # add policies for export route targets
        ps = PolicyStatement(name=DMUtils.make_export_name(ri_name))
        ps.set_comment(DMUtils.vn_ps_comment(vn, "Export"))
        then = Then()
        ps.add_term(Term(name="t1", then=then))
        for route_target in export_targets:
            comm = Community(
                add='',
                community_name=DMUtils.make_community_name(route_target))
            then.add_community(comm)
            then.set_accept('')
            self.add_vni_option(network_id,
                                DMUtils.make_community_name(route_target))
        policy_config.add_policy_statement(ps)
        self.add_to_global_switch_opts(DMUtils.make_export_name(ri_name),
                                       False)

        # add policies for import route targets
        ps = PolicyStatement(name=DMUtils.make_import_name(ri_name))
        ps.set_comment(DMUtils.vn_ps_comment(vn, "Import"))
        from_ = From()
        term = Term(name="t1", fromxx=from_)
        ps.add_term(term)
        for route_target in import_targets:
            from_.add_community(DMUtils.make_community_name(route_target))
            self.add_vni_option(network_id,
                                DMUtils.make_community_name(route_target))
        term.set_then(Then(accept=''))
        ps.set_then(Then(reject=''))
        policy_config.add_policy_statement(ps)
        self.add_to_global_switch_opts(DMUtils.make_import_name(ri_name), True)

        # add vlan config
        if is_l2 and vni and self.is_family_configured(self.bgp_params,
                                                       "e-vpn"):
            self.add_vlan_config(ri_name, vni)

        # add L2 EVPN and BD config
        interfaces_config = self.interfaces_config
        proto_config = self.proto_config
        if (is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            ri.set_vtep_source_interface("lo0.0")
            evpn = Evpn(encapsulation='vxlan', extended_vni_list='all')
            self.set_evpn_default_gateway_params(evpn)
            ri.set_protocols(RoutingInstanceProtocols(evpn=evpn))

            interfaces_config = self.interfaces_config or Interfaces(
                comment=DMUtils.interfaces_comment())
            if is_l2_l3:
                irb_intf = Interface(name='irb', gratuitous_arp_reply='')
                interfaces_config.add_interface(irb_intf)
                if gateways is not None:
                    intf_unit = Unit(name=str(network_id),
                                     comment=DMUtils.vn_irb_comment(
                                         vn, False, is_l2_l3))
                    irb_intf.add_unit(intf_unit)
                    if self.is_spine():
                        intf_unit.set_proxy_macip_advertisement('')
                    family = Family()
                    intf_unit.set_family(family)
                    inet = None
                    inet6 = None
                    for (irb_ip, gateway) in gateways:
                        if ':' in irb_ip:
                            if not inet6:
                                inet6 = FamilyInet6()
                                family.set_inet6(inet6)
                            addr = Address()
                            inet6.add_address(addr)
                        else:
                            if not inet:
                                inet = FamilyInet()
                                family.set_inet(inet)
                            addr = Address()
                            inet.add_address(addr)
                        addr.set_name(irb_ip)
                        addr.set_comment(DMUtils.irb_ip_comment(irb_ip))
                        if len(gateway) and gateway != '0.0.0.0':
                            addr.set_virtual_gateway_address(gateway)

            self.build_l2_evpn_interface_config(interfaces_config, interfaces,
                                                vn)

        if (not is_l2 and not is_l2_l3 and gateways):
            interfaces_config = self.interfaces_config or Interfaces(
                comment=DMUtils.interfaces_comment())
            ifl_num = str(1000 + int(network_id))
            lo_intf = Interface(name="lo0")
            interfaces_config.add_interface(lo_intf)
            intf_unit = Unit(name=ifl_num,
                             comment=DMUtils.l3_lo_intf_comment(vn))
            lo_intf.add_unit(intf_unit)
            family = Family()
            intf_unit.set_family(family)
            inet = None
            inet6 = None
            for (lo_ip, _) in gateways:
                subnet = lo_ip
                (ip, _) = lo_ip.split('/')
                if ':' in lo_ip:
                    if not inet6:
                        inet6 = FamilyInet6()
                        family.set_inet6(inet6)
                    addr = Address()
                    inet6.add_address(addr)
                    lo_ip = ip + '/' + '128'
                else:
                    if not inet:
                        inet = FamilyInet()
                        family.set_inet(inet)
                    addr = Address()
                    inet.add_address(addr)
                    lo_ip = ip + '/' + '32'
                addr.set_name(lo_ip)
                addr.set_comment(DMUtils.lo0_ip_comment(subnet))
            ri.add_interface(
                Interface(name="lo0." + ifl_num,
                          comment=DMUtils.lo0_ri_intf_comment(vn)))

        self.policy_config = policy_config
        self.proto_config = proto_config
        self.interfaces_config = interfaces_config
        self.route_targets |= import_targets | export_targets
        self.ri_config = ri_config
Esempio n. 54
0
    def build_ri_config(self):
        vn_dict = self.get_vn_li_map()
        self.physical_router.evaluate_vn_irb_ip_map(set(vn_dict.keys()),
                                                    'l2_l3', 'irb', False)
        self.physical_router.evaluate_vn_irb_ip_map(set(vn_dict.keys()), 'l3',
                                                    'lo0', True)
        vn_irb_ip_map = self.physical_router.get_vn_irb_ip_map()

        for vn_id, interfaces in vn_dict.items():
            vn_obj = VirtualNetworkDM.get(vn_id)
            if (vn_obj is None or vn_obj.get_vxlan_vni() is None
                    or vn_obj.vn_network_id is None):
                continue
            if not self.check_vn_is_allowed(vn_obj):
                continue
            export_set = None
            import_set = None
            for ri_id in vn_obj.routing_instances:
                # Find the primary RI by matching the name
                ri_obj = RoutingInstanceDM.get(ri_id)
                if ri_obj is None:
                    continue
                if ri_obj.fq_name[-1] == vn_obj.fq_name[-1]:
                    vrf_name_l2 = DMUtils.make_vrf_name(
                        vn_obj.fq_name[-1], vn_obj.vn_network_id, 'l2')
                    vrf_name_l3 = DMUtils.make_vrf_name(
                        vn_obj.fq_name[-1], vn_obj.vn_network_id, 'l3')
                    export_set = copy.copy(ri_obj.export_targets)
                    import_set = copy.copy(ri_obj.import_targets)
                    for ri2_id in ri_obj.routing_instances:
                        ri2 = RoutingInstanceDM.get(ri2_id)
                        if ri2 is None:
                            continue
                        import_set |= ri2.export_targets

                    if vn_obj.get_forwarding_mode() in ['l2', 'l2_l3']:
                        irb_ips = None
                        if vn_obj.get_forwarding_mode() == 'l2_l3':
                            irb_ips = vn_irb_ip_map['irb'].get(vn_id, [])

                        ri_conf = {'ri_name': vrf_name_l2, 'vn': vn_obj}
                        ri_conf['is_l2'] = True
                        ri_conf['is_l2_l3'] = (
                            vn_obj.get_forwarding_mode() == 'l2_l3')
                        ri_conf['import_targets'] = import_set
                        ri_conf['export_targets'] = export_set
                        ri_conf['prefixes'] = vn_obj.get_prefixes()
                        ri_conf['gateways'] = irb_ips
                        ri_conf['interfaces'] = interfaces
                        ri_conf['vni'] = vn_obj.get_vxlan_vni()
                        ri_conf['network_id'] = vn_obj.vn_network_id
                        self.add_routing_instance(ri_conf)

                    if vn_obj.get_forwarding_mode() in ['l3']:
                        interfaces = []
                        lo0_ips = vn_irb_ip_map['lo0'].get(vn_id, [])
                        ri_conf = {'ri_name': vrf_name_l3, 'vn': vn_obj}
                        ri_conf['is_l2'] = False
                        ri_conf['is_l2_l3'] = False
                        ri_conf['import_targets'] = import_set
                        ri_conf['export_targets'] = export_set
                        ri_conf['prefixes'] = vn_obj.get_prefixes()
                        ri_conf['interfaces'] = interfaces
                        ri_conf['gateways'] = lo0_ips
                        ri_conf['network_id'] = vn_obj.vn_network_id
                        self.add_routing_instance(ri_conf)
                    break
        return
Esempio n. 55
0
 def init_global_switch_opts(self):
     if self.global_switch_options_config is None:
         self.global_switch_options_config = SwitchOptions(
             comment=DMUtils.switch_options_comment())
     self.global_switch_options_config.set_vtep_source_interface("lo0.0")
Esempio n. 56
0
    def add_routing_instance(self, ri_conf):
        ri_name = ri_conf.get("ri_name")
        is_l2 = ri_conf.get("is_l2", False)
        is_l2_l3 = ri_conf.get("is_l2_l3", False)
        import_targets = ri_conf.get("import_targets", set())
        export_targets = ri_conf.get("export_targets", set())
        prefixes = ri_conf.get("prefixes", [])
        gateways = ri_conf.get("gateways", [])
        router_external = ri_conf.get("router_external", False)
        interfaces = ri_conf.get("interfaces", [])
        vni = ri_conf.get("vni", None)
        fip_map = ri_conf.get("fip_map", None)
        network_id = ri_conf.get("network_id", None)
        static_routes = ri_conf.get("static_routes", {})
        no_vrf_table_label = ri_conf.get("no_vrf_table_label", False)
        restrict_proxy_arp = ri_conf.get("restrict_proxy_arp", False)
        highest_enapsulation_priority = \
                  ri_conf.get("highest_enapsulation_priority") or "MPLSoGRE"

        self.routing_instances[ri_name] = ri_conf
        ri_config = self.ri_config or RoutingInstances()
        policy_config = self.policy_config or PolicyOptions()
        ri = Instance(name=ri_name)
        ri_config.add_instance(ri)
        ri_opt = None
        if router_external and is_l2 == False:
            ri_opt = RoutingInstanceRoutingOptions(static=Static(
                route=[Route(name="0.0.0.0/0", next_table="inet.0")]))
            ri.set_routing_options(ri_opt)

        # for both l2 and l3
        ri.set_vrf_import(DMUtils.make_import_name(ri_name))
        ri.set_vrf_export(DMUtils.make_export_name(ri_name))

        has_ipv6_prefixes = DMUtils.has_ipv6_prefixes(prefixes)
        has_ipv4_prefixes = DMUtils.has_ipv4_prefixes(prefixes)

        if not is_l2:
            if ri_opt is None:
                ri_opt = RoutingInstanceRoutingOptions()
                ri.set_routing_options(ri_opt)
            if prefixes and fip_map is None:
                static_config = ri_opt.get_static()
                if not static_config:
                    static_config = Static()
                    ri_opt.set_static(static_config)
                rib_config_v6 = None
                static_config_v6 = None
                for prefix in prefixes:
                    if ':' in prefix and not rib_config_v6:
                        static_config_v6 = Static()
                        rib_config_v6 = RIB(name=ri_name + ".inet6.0")
                        rib_config_v6.set_static(static_config_v6)
                        ri_opt.set_rib(rib_config_v6)
                    if ':' in prefix:
                        static_config_v6.add_route(
                            Route(name=prefix, discard=''))
                    else:
                        static_config.add_route(Route(name=prefix, discard=''))
                    if router_external:
                        self.add_to_global_ri_opts(prefix)

            ri.set_instance_type("vrf")
            if not no_vrf_table_label:
                ri.set_vrf_table_label('')  # only for l3
            if fip_map is None:
                for interface in interfaces:
                    ri.add_interface(Interface(name=interface.name))
            if static_routes:
                self.add_static_routes(ri_opt, static_routes)
            if has_ipv4_prefixes:
                ri_opt.set_auto_export(
                    AutoExport(family=Family(inet=FamilyInet(unicast=''))))
            if has_ipv6_prefixes:
                ri_opt.set_auto_export(
                    AutoExport(family=Family(inet6=FamilyInet6(unicast=''))))
        else:
            if highest_enapsulation_priority == "VXLAN":
                ri.set_instance_type("virtual-switch")
            elif highest_enapsulation_priority in ["MPLSoGRE", "MPLSoUDP"]:
                ri.set_instance_type("evpn")

        if fip_map is not None:
            if ri_opt is None:
                ri_opt = RoutingInstanceRoutingOptions()
                ri.set_routing_options(ri_opt)
            static_config = ri_opt.get_static()
            if not static_config:
                static_config = Static()
                ri_opt.set_static(static_config)
            static_config.add_route(
                Route(name="0.0.0.0/0", next_hop=interfaces[0].name))
            ri.add_interface(Interface(name=interfaces[0].name))

            public_vrf_ips = {}
            for pip in fip_map.values():
                if pip["vrf_name"] not in public_vrf_ips:
                    public_vrf_ips[pip["vrf_name"]] = set()
                public_vrf_ips[pip["vrf_name"]].add(pip["floating_ip"])

            for public_vrf, fips in public_vrf_ips.items():
                ri_public = Instance(name=public_vrf)
                ri_config.add_instance(ri_public)
                ri_public.add_interface(Interface(name=interfaces[1].name))

                ri_opt = RoutingInstanceRoutingOptions()
                ri_public.set_routing_options(ri_opt)
                static_config = Static()
                ri_opt.set_static(static_config)

                for fip in fips:
                    static_config.add_route(
                        Route(name=fip + "/32", next_hop=interfaces[1].name))

        # add policies for export route targets
        ps = PolicyStatement(name=DMUtils.make_export_name(ri_name))
        then = Then()
        ps.set_term(Term(name="t1", then=then))
        for route_target in export_targets:
            comm = Community(
                add='',
                community_name=DMUtils.make_community_name(route_target))
            then.add_community(comm)
        if fip_map is not None:
            # for nat instance
            then.set_reject('')
        else:
            then.set_accept('')
        policy_config.add_policy_statement(ps)

        # add policies for import route targets
        ps = PolicyStatement(name=DMUtils.make_import_name(ri_name))
        from_ = From()
        term = Term(name="t1", fromxx=from_)
        ps.set_term(term)
        for route_target in import_targets:
            from_.add_community(DMUtils.make_community_name(route_target))
        term.set_then(Then(accept=''))
        ps.set_then(Then(reject=''))
        policy_config.add_policy_statement(ps)

        # add firewall config for public VRF
        forwarding_options_config = self.forwarding_options_config
        firewall_config = self.firewall_config
        if router_external and is_l2 == False:
            forwarding_options_config = (self.forwarding_options_config
                                         or ForwardingOptions())
            firewall_config = self.firewall_config or Firewall()
            if has_ipv4_prefixes and not self.inet4_forwarding_filter:
                #create single instance inet4 filter
                self.inet4_forwarding_filter = self.add_inet_public_vrf_filter(
                    forwarding_options_config, firewall_config, "inet")
            if has_ipv6_prefixes and not self.inet6_forwarding_filter:
                #create single instance inet6 filter
                self.inet6_forwarding_filter = self.add_inet_public_vrf_filter(
                    forwarding_options_config, firewall_config, "inet6")
            if has_ipv4_prefixes:
                #add terms to inet4 filter
                term = self.add_inet_filter_term(ri_name, prefixes, "inet4")
                # insert before the last term
                terms = self.inet4_forwarding_filter.get_term()
                terms = [term] + (terms or [])
                self.inet4_forwarding_filter.set_term(terms)
            if has_ipv6_prefixes:
                #add terms to inet6 filter
                term = self.add_inet_filter_term(ri_name, prefixes, "inet6")
                # insert before the last term
                terms = self.inet6_forwarding_filter.get_term()
                terms = [term] + (terms or [])
                self.inet6_forwarding_filter.set_term(terms)

        if fip_map is not None:
            firewall_config = firewall_config or Firewall()
            f = FirewallFilter(
                name=DMUtils.make_private_vrf_filter_name(ri_name))
            ff = firewall_config.get_family()
            if not ff:
                ff = FirewallFamily()
                firewall_config.set_family(ff)
            inet = ff.get_inet()
            if not inet:
                inet = FirewallInet()
                ff.set_inet(inet)
            inet.add_filter(f)

            term = Term(name=DMUtils.make_vrf_term_name(ri_name))
            from_ = From()
            for fip_user_ip in fip_map.keys():
                from_.add_source_address(fip_user_ip)
            term.set_from(from_)
            term.set_then(Then(routing_instance=[ri_name]))
            f.add_term(term)

            term = Term(name="default-term", then=Then(accept=''))
            f.add_term(term)

            interfaces_config = self.interfaces_config or Interfaces()
            irb_intf = Interface(name="irb")
            interfaces_config.add_interface(irb_intf)

            intf_unit = Unit(name=str(network_id))
            if restrict_proxy_arp:
                intf_unit.set_proxy_arp(ProxyArp(restricted=''))
            inet = FamilyInet()
            inet.set_filter(
                InetFilter(
                    input=DMUtils.make_private_vrf_filter_name(ri_name)))
            intf_unit.set_family(Family(inet=inet))
            irb_intf.add_unit(intf_unit)

        # add L2 EVPN and BD config
        bd_config = None
        interfaces_config = self.interfaces_config
        proto_config = self.proto_config
        if (is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            ri.set_vtep_source_interface("lo0.0")
            if highest_enapsulation_priority == "VXLAN":
                bd_config = BridgeDomains()
                ri.set_bridge_domains(bd_config)
                bd = Domain(name=DMUtils.make_bridge_name(vni),
                            vlan_id='none',
                            vxlan=VXLan(vni=vni))
                bd_config.add_domain(bd)
                for interface in interfaces:
                    bd.add_interface(Interface(name=interface.name))
                if is_l2_l3:
                    # network_id is unique, hence irb
                    bd.set_routing_interface("irb." + str(network_id))
                ri.set_protocols(
                    RoutingInstanceProtocols(evpn=Evpn(
                        encapsulation='vxlan', extended_vni_list='all')))
            elif highest_enapsulation_priority in ["MPLSoGRE", "MPLSoUDP"]:
                ri.set_vlan_id('none')
                if is_l2_l3:
                    # network_id is unique, hence irb
                    ri.set_routing_interface("irb." + str(network_id))
                evpn = Evpn()
                for interface in interfaces:
                    evpn.add_interface(Interface(name=interface.name))
                ri.set_protocols(RoutingInstanceProtocols(evpn=evpn))

            interfaces_config = self.interfaces_config or Interfaces()
            if is_l2_l3:
                irb_intf = Interface(name='irb', gratuitous_arp_reply='')
                interfaces_config.add_interface(irb_intf)
                if gateways is not None:
                    intf_unit = Unit(name=str(network_id))
                    irb_intf.add_unit(intf_unit)
                    family = Family()
                    intf_unit.set_family(family)
                    inet = None
                    inet6 = None
                    for (irb_ip, gateway) in gateways:
                        if ':' in irb_ip:
                            if not inet6:
                                inet6 = FamilyInet6()
                                family.set_inet6(inet6)
                            addr = Address()
                            inet6.add_address(addr)
                        else:
                            if not inet:
                                inet = FamilyInet()
                                family.set_inet(inet)
                            addr = Address()
                            inet.add_address(addr)
                        addr.set_name(irb_ip)
                        if len(gateway) and gateway != '0.0.0.0':
                            addr.set_virtual_gateway_address(gateway)

            lo_intf = Interface(name="lo0")
            interfaces_config.add_interface(lo_intf)
            fam_inet = FamilyInet(address=[
                Address(name=self.bgp_params['address'] + "/32",
                        primary='',
                        preferred='')
            ])
            intf_unit = Unit(name="0", family=Family(inet=fam_inet))
            lo_intf.add_unit(intf_unit)

            self.build_l2_evpn_interface_config(interfaces_config, interfaces)

        if (not is_l2 and not is_l2_l3 and gateways):
            interfaces_config = self.interfaces_config or Interfaces()
            ifl_num = str(1000 + int(network_id))
            lo_intf = Interface(name="lo0")
            interfaces_config.add_interface(lo_intf)
            intf_unit = Unit(name=ifl_num)
            lo_intf.add_unit(intf_unit)
            family = Family()
            intf_unit.set_family(family)
            inet = None
            inet6 = None
            for (lo_ip, _) in gateways:
                (ip, _) = lo_ip.split('/')
                if ':' in lo_ip:
                    if not inet6:
                        inet6 = FamilyInet6()
                        family.set_inet6(inet6)
                    addr = Address()
                    inet6.add_address(addr)
                    lo_ip = ip + '/' + '128'
                else:
                    if not inet:
                        inet = FamilyInet()
                        family.set_inet(inet)
                    addr = Address()
                    inet.add_address(addr)
                    lo_ip = ip + '/' + '32'
                addr.set_name(lo_ip)
            ri.add_interface(Interface(name="lo0." + ifl_num))

        # fip services config
        services_config = self.services_config
        if fip_map is not None:
            services_config = self.services_config or Services()
            service_name = DMUtils.make_services_set_name(ri_name)
            service_set = ServiceSet(name=service_name)
            services_config.add_service_set(service_set)
            nat_rule = NATRules(name=service_name + "-sn-rule")
            service_set.add_nat_rules(
                NATRules(name=DMUtils.make_snat_rule_name(ri_name)))
            service_set.add_nat_rules(
                NATRules(name=DMUtils.make_dnat_rule_name(ri_name)))
            next_hop_service = NextHopService(
                inside_service_interface=interfaces[0].name,
                outside_service_interface=interfaces[1].name)
            service_set.set_next_hop_service(next_hop_service)

            nat = NAT(allow_overlapping_nat_pools='')
            services_config.add_nat(nat)
            snat_rule = Rule(name=DMUtils.make_snat_rule_name(ri_name),
                             match_direction="input")
            nat.add_rule(snat_rule)
            dnat_rule = Rule(name=DMUtils.make_dnat_rule_name(ri_name),
                             match_direction="output")
            nat.add_rule(dnat_rule)

            for pip, fip_vn in fip_map.items():
                fip = fip_vn["floating_ip"]
                term = Term(name=DMUtils.make_ip_term_name(pip))
                snat_rule.set_term(term)
                # private ip
                from_ = From(source_address=[pip + "/32"])
                term.set_from(from_)
                # public ip
                then_ = Then()
                term.set_then(then_)
                translated = Translated(
                    source_prefix=fip + "/32",
                    translation_type=TranslationType(basic_nat44=''))
                then_.set_translated(translated)

                term = Term(name=DMUtils.make_ip_term_name(fip))
                dnat_rule.set_term(term)

                # public ip
                from_ = From(destination_address=[fip + "/32"])
                term.set_from(from_)
                # private ip
                then_ = Then()
                term.set_then(then_)
                translated = Translated(
                    destination_prefix=pip + "/32",
                    translation_type=TranslationType(dnat_44=''))
                then_.set_translated(translated)

            interfaces_config = self.interfaces_config or Interfaces()
            si_intf = Interface(name=interfaces[0].ifd_name)
            interfaces_config.add_interface(si_intf)

            intf_unit = Unit(name=interfaces[0].unit)
            si_intf.add_unit(intf_unit)
            family = Family(inet=FamilyInet())
            intf_unit.set_family(family)
            intf_unit.set_service_domain("inside")

            intf_unit = Unit(name=interfaces[1].unit)
            si_intf.add_unit(intf_unit)
            family = Family(inet=FamilyInet())
            intf_unit.set_family(family)
            intf_unit.set_service_domain("outside")

        self.forwarding_options_config = forwarding_options_config
        self.firewall_config = firewall_config
        self.policy_config = policy_config
        self.proto_config = proto_config
        self.interfaces_config = interfaces_config
        self.services_config = services_config
        self.route_targets |= import_targets | export_targets
        self.ri_config = ri_config
Esempio n. 57
0
 def set_chassis_config(self):
     device_count =  DMUtils.get_max_ae_device_count()
     aggr_devices = AggregatedDevices(Ethernet(device_count=device_count))
     if not self.chassis_config:
         self.chassis_config = Chassis()
     self.chassis_config.set_aggregated_devices(aggr_devices)
Esempio n. 58
0
    def add_routing_instance(self, ri_conf):
        ri_name = ri_conf.get("ri_name")
        vn = ri_conf.get("vn")
        is_l2 = ri_conf.get("is_l2", False)
        is_l2_l3 = ri_conf.get("is_l2_l3", False)
        import_targets = ri_conf.get("import_targets", set())
        export_targets = ri_conf.get("export_targets", set())
        prefixes = ri_conf.get("prefixes", [])
        gateways = ri_conf.get("gateways", [])
        interfaces = ri_conf.get("interfaces", [])
        vni = ri_conf.get("vni", None)
        network_id = ri_conf.get("network_id", None)
        is_internal_vn = True if '_contrail_lr_internal_vn_' in vn.name else False

        self.routing_instances[ri_name] = ri_conf
        ri_config = None
        policy_config = self.policy_config or \
                       PolicyOptions(comment=DMUtils.policy_options_comment())
        ri = None
        ri_opt = None
        ri_config = self.ri_config or \
                   RoutingInstances(comment=DMUtils.routing_instances_comment())
        ri = Instance(name=ri_name)
        if not is_l2:
            ri_config.add_instance(ri)
            ri.set_vrf_import(DMUtils.make_import_name(ri_name))
            ri.set_vrf_export(DMUtils.make_export_name(ri_name))

        has_ipv6_prefixes = DMUtils.has_ipv6_prefixes(prefixes)
        has_ipv4_prefixes = DMUtils.has_ipv4_prefixes(prefixes)

        if not is_l2:
            if ri_opt is None:
                ri_opt = RoutingInstanceRoutingOptions()
                ri.set_routing_options(ri_opt)

            ri.set_instance_type("vrf")
            for interface in interfaces:
                ri.add_interface(Interface(name=interface.name))
            family = Family()
            if has_ipv4_prefixes:
                family.set_inet(FamilyInet(unicast=''))
            if has_ipv6_prefixes:
                family.set_inet6(FamilyInet6(unicast=''))
            if has_ipv4_prefixes or has_ipv6_prefixes:
                auto_export = AutoExport(family=family)
                ri_opt.set_auto_export(auto_export)

        if is_internal_vn:
            self.internal_vn_ris.append(ri)
            self.add_bogus_lo0(ri, network_id, vn)

        if self.is_spine() and is_l2_l3:
            self.add_irb_config(ri_conf)
            self.attach_irb(ri_conf, ri)

        # add policies for export route targets
        if self.is_spine():
            ps = PolicyStatement(name=DMUtils.make_export_name(ri_name))
            ps.set_comment(DMUtils.vn_ps_comment(vn, "Export"))
            then = Then()
            ps.add_term(Term(name="t1", then=then))
            for route_target in export_targets:
                comm = Community(
                    add='',
                    community_name=DMUtils.make_community_name(route_target))
                then.add_community(comm)
                then.set_accept('')
            policy_config.add_policy_statement(ps)
            self.add_to_global_switch_opts(DMUtils.make_export_name(ri_name),
                                           False)

        # add policies for import route targets
        ps = PolicyStatement(name=DMUtils.make_import_name(ri_name))
        ps.set_comment(DMUtils.vn_ps_comment(vn, "Import"))

        # add term switch policy
        from_ = From()
        term = Term(name=DMUtils.get_switch_policy_name(), fromxx=from_)
        ps.add_term(term)
        from_.add_community(DMUtils.get_switch_policy_name())
        term.set_then(Then(accept=''))

        from_ = From()
        term = Term(name="t1", fromxx=from_)
        ps.add_term(term)
        for route_target in import_targets:
            from_.add_community(DMUtils.make_community_name(route_target))
            if not is_internal_vn:
                self.add_vni_option(vni or network_id, route_target)
        term.set_then(Then(accept=''))
        policy_config.add_policy_statement(ps)
        self.add_to_global_switch_opts(DMUtils.make_import_name(ri_name), True)

        # add L2 EVPN and BD config
        interfaces_config = self.interfaces_config
        if (is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            # add vlan config
            vlan_conf = self.add_vlan_config(ri_name, vni, is_l2_l3,
                                             "irb." + str(network_id))
            interfaces_config = self.interfaces_config or Interfaces(
                comment=DMUtils.interfaces_comment())
            self.build_l2_evpn_interface_config(interfaces_config, interfaces,
                                                vn, vlan_conf)

        if (not is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            ri.set_vtep_source_interface("lo0.0")
            evpn = self.build_evpn_config()
            if evpn:
                ri.set_protocols(RoutingInstanceProtocols(evpn=evpn))
            #add vlans
            self.add_ri_vlan_config(ri, vni)

        if (not is_l2 and not is_l2_l3 and gateways):
            interfaces_config = self.interfaces_config or \
                               Interfaces(comment=DMUtils.interfaces_comment())
            ifl_num = str(1000 + int(network_id))
            lo_intf = Interface(name="lo0")
            interfaces_config.add_interface(lo_intf)
            intf_unit = Unit(name=ifl_num,
                             comment=DMUtils.l3_lo_intf_comment(vn))
            lo_intf.add_unit(intf_unit)
            family = Family()
            intf_unit.set_family(family)
            inet = None
            inet6 = None
            for (lo_ip, _) in gateways:
                subnet = lo_ip
                (ip, _) = lo_ip.split('/')
                if ':' in lo_ip:
                    if not inet6:
                        inet6 = FamilyInet6()
                        family.set_inet6(inet6)
                    addr = Address()
                    inet6.add_address(addr)
                    lo_ip = ip + '/' + '128'
                else:
                    if not inet:
                        inet = FamilyInet()
                        family.set_inet(inet)
                    addr = Address()
                    inet.add_address(addr)
                    lo_ip = ip + '/' + '32'
                addr.set_name(lo_ip)
                addr.set_comment(DMUtils.lo0_ip_comment(subnet))
            ri.add_interface(
                Interface(name="lo0." + ifl_num,
                          comment=DMUtils.lo0_ri_intf_comment(vn)))

        self.policy_config = policy_config
        self.interfaces_config = interfaces_config
        self.route_targets |= import_targets | export_targets
        self.ri_config = ri_config
    def build_ri_config(self):
        if not self.is_spine():
            esi_map = self.get_ae_alloc_esi_map()
            self.physical_router.evaluate_ae_id_map(esi_map)
            self.build_ae_config(esi_map)
        vn_dict = self.get_vn_li_map()
        vn_irb_ip_map = None
        if self.is_spine():
            self.physical_router.evaluate_vn_irb_ip_map(
                set(vn_dict.keys()), 'l2_l3', 'irb', False)
            self.physical_router.evaluate_vn_irb_ip_map(
                set(vn_dict.keys()), 'l3', 'lo0', True)
            vn_irb_ip_map = self.physical_router.get_vn_irb_ip_map()

        for vn_id, interfaces in vn_dict.items():
            vn_obj = VirtualNetworkDM.get(vn_id)
            if (vn_obj is None or vn_obj.get_vxlan_vni() is None
                    or vn_obj.vn_network_id is None):
                continue

            export_set = None
            import_set = None
            for ri_id in vn_obj.routing_instances:
                # Find the primary RI by matching the name
                ri_obj = RoutingInstanceDM.get(ri_id)
                if ri_obj is None:
                    continue
                if ri_obj.fq_name[-1] == vn_obj.fq_name[-1]:
                    vrf_name_l2 = DMUtils.make_vrf_name(
                        vn_obj.fq_name[-1], vn_obj.vn_network_id, 'l2')
                    vrf_name_l3 = DMUtils.make_vrf_name(
                        vn_obj.fq_name[-1], vn_obj.vn_network_id, 'l3')
                    export_set = copy.copy(ri_obj.export_targets)
                    import_set = copy.copy(ri_obj.import_targets)
                    if self.is_spine():
                        for ri2_id in ri_obj.routing_instances:
                            ri2 = RoutingInstanceDM.get(ri2_id)
                            if ri2 is None:
                                continue
                            import_set |= ri2.export_targets

                    if vn_obj.get_forwarding_mode() in ['l2', 'l2_l3']:
                        irb_ips = None
                        if vn_obj.get_forwarding_mode(
                        ) == 'l2_l3' and self.is_spine():
                            irb_ips = vn_irb_ip_map['irb'].get(vn_id, [])

                        ri_conf = {
                            'ri_name':
                            vrf_name_l2,
                            'vn':
                            vn_obj,
                            'is_l2':
                            True,
                            'is_l2_l3':
                            (vn_obj.get_forwarding_mode() == 'l2_l3'),
                            'import_targets':
                            import_set,
                            'prefixes':
                            vn_obj.get_prefixes(),
                            'gateways':
                            irb_ips,
                            'router_external':
                            vn_obj.router_external,
                            'interfaces':
                            interfaces,
                            'vni':
                            vn_obj.get_vxlan_vni(),
                            'network_id':
                            vn_obj.vn_network_id,
                            'highest_encapsulation_priority':
                            GlobalVRouterConfigDM.global_encapsulation_priority
                        }
                        if self.is_spine():
                            ri_conf['export_targets'] = export_set
                        self.add_routing_instance(ri_conf)

                    if vn_obj.get_forwarding_mode() in [
                            'l3'
                    ] and self.is_l3_supported(vn_obj):
                        interfaces = []
                        lo0_ips = vn_irb_ip_map['lo0'].get(vn_id, [])
                        ri_conf = {
                            'ri_name': vrf_name_l3,
                            'vn': vn_obj,
                            'is_l2': False,
                            'is_l2_l3': False,
                            'import_targets': import_set,
                            'export_targets': export_set,
                            'prefixes': vn_obj.get_prefixes(),
                            'router_external': vn_obj.router_external,
                            'interfaces': interfaces,
                            'gateways': lo0_ips,
                            'network_id': vn_obj.vn_network_id
                        }
                        self.add_routing_instance(ri_conf)
                    break

            if export_set and len(vn_obj.instance_ip_map) > 0:
                vrf_name = DMUtils.make_vrf_name(vn_obj.fq_name[-1],
                                                 vn_obj.vn_network_id, 'l3',
                                                 True)
                ri_conf = {
                    'ri_name': vrf_name,
                    'vn': vn_obj,
                    'import_targets': import_set,
                    'fip_map': vn_obj.instance_ip_map,
                    'network_id': vn_obj.vn_network_id
                }
                self.add_routing_instance(ri_conf)
        return
    def add_routing_instance(self, ri_conf):
        ri_name = ri_conf.get("ri_name")
        vn = ri_conf.get("vn")
        is_l2 = ri_conf.get("is_l2", False)
        is_l2_l3 = ri_conf.get("is_l2_l3", False)
        import_targets = ri_conf.get("import_targets", set())
        export_targets = ri_conf.get("export_targets", set())
        prefixes = ri_conf.get("prefixes", [])
        gateways = ri_conf.get("gateways", [])
        router_external = ri_conf.get("router_external", False)
        interfaces = ri_conf.get("interfaces", [])
        vni = ri_conf.get("vni", None)
        fip_map = ri_conf.get("fip_map", None)
        network_id = ri_conf.get("network_id", None)
        is_internal_vn = True if '_contrail_lr_internal_vn_' in vn.name else False
        highest_encapsulation_priority = \
            ri_conf.get("highest_encapsulation_priority") or "MPLSoGRE"

        self.routing_instances[ri_name] = ri_conf
        self.ri_config = self.ri_config or []
        self.policy_config = self.policy_config or\
                             Policy(comment=DMUtils.policy_options_comment())
        ri = RoutingInstance(name=ri_name)
        if vn:
            is_nat = True if fip_map else False
            ri.set_comment(
                DMUtils.vn_ri_comment(vn, is_l2, is_l2_l3, is_nat,
                                      router_external))
        self.ri_config.append(ri)

        ri.set_is_public_network(router_external)

        has_ipv6_prefixes = DMUtils.has_ipv6_prefixes(prefixes)
        has_ipv4_prefixes = DMUtils.has_ipv4_prefixes(prefixes)

        if not is_l2:
            ri.set_instance_type("vrf")
            if fip_map is None:
                for interface in interfaces:
                    ri.add_interfaces(LogicalInterface(name=interface.name))
        else:
            if highest_encapsulation_priority == "VXLAN":
                ri.set_routing_instance_type("virtual-switch")
            elif highest_encapsulation_priority in ["MPLSoGRE", "MPLSoUDP"]:
                ri.set_routing_instance_type("evpn")

        if is_internal_vn:
            self.internal_vn_ris.append(ri)
            self.add_bogus_lo0(ri, network_id, vn)

        if self.is_spine() and is_l2_l3:
            self.add_irb_config(ri_conf)
            self.attach_irb(ri_conf, ri)

        if fip_map is not None:
            ri.add_interfaces(LogicalInterface(name=interfaces[0].name))

            public_vrf_ips = {}
            for pip in fip_map.values():
                if pip["vrf_name"] not in public_vrf_ips:
                    public_vrf_ips[pip["vrf_name"]] = set()
                public_vrf_ips[pip["vrf_name"]].add(pip["floating_ip"])

            for public_vrf, fips in public_vrf_ips.items():
                floating_ips = []
                ri.add_floating_ip_list(
                    FloatingIpList(public_routing_instance=public_vrf,
                                   floating_ips=floating_ips))
                for fip in fips:
                    floating_ips.append(FloatingIpMap(floating_ip=fip))

        # add policies for export route targets
        if self.is_spine():
            p = PolicyRule(name=DMUtils.make_export_name(ri_name))
            p.set_comment(DMUtils.vn_ps_comment(vn, "Export"))
            then = Then()
            p.add_term(Term(name="t1", then=then))
            for route_target in export_targets:
                then.add_community(DMUtils.make_community_name(route_target))
            then.set_accept_or_reject(True)
            self.policy_config.add_policy_rule(p)

        # add policies for import route targets
        p = PolicyRule(name=DMUtils.make_import_name(ri_name))
        p.set_comment(DMUtils.vn_ps_comment(vn, "Import"))

        # add term switch policy
        from_ = From()
        term = Term(name=DMUtils.get_switch_policy_name(), fromxx=from_)
        p.add_term(term)
        from_.add_community(DMUtils.get_switch_policy_name())
        term.set_then(Then(accept_or_reject=True))

        from_ = From()
        term = Term(name="t1", fromxx=from_)
        p.add_term(term)
        for route_target in import_targets:
            from_.add_community(DMUtils.make_community_name(route_target))
            if not is_internal_vn:
                self.add_vni_option(vni or network_id, route_target)
        term.set_then(Then(accept_or_reject=True))
        self.policy_config.add_policy_rule(p)

        # add L2 EVPN and BD config
        if (is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            # add vlan config
            vlan_conf = self.add_vlan_config(ri_name, vni, is_l2_l3,
                                             "irb." + str(network_id))
            self.interfaces_config = self.interfaces_config or []
            self.build_l2_evpn_interface_config(self.interfaces_config,
                                                interfaces, vn, vlan_conf)

        if (not is_l2 and vni is not None
                and self.is_family_configured(self.bgp_params, "e-vpn")):
            ri.set_vtep_source_interface("lo0.0")
            evpn = self.build_evpn_config()
            if evpn:
                ri.set_protocols(RoutingInstanceProtocols(evpn=evpn))
            #add vlans
            self.add_ri_vlan_config(ri, vni)

        if (not is_l2 and not is_l2_l3 and gateways):
            self.interfaces_config = self.interfaces_config or []
            ifl_num = str(1000 + int(network_id))
            lo_intf = Interface(name="lo0")
            interfaces_config.add_interface(lo_intf)
            intf_unit = Unit(name=ifl_num,
                             comment=DMUtils.l3_lo_intf_comment(vn))
            lo_intf.add_logical_interfaces(intf_unit)
            family = Family()
            intf_unit.set_family(family)
            inet = None
            inet6 = None
            for (lo_ip, _) in gateways:
                subnet = lo_ip
                (ip, _) = lo_ip.split('/')
                if ':' in lo_ip:
                    if not inet6:
                        inet6 = FamilyInet6()
                        family.set_inet6(inet6)
                    addr = Address()
                    inet6.add_address(addr)
                    lo_ip = ip + '/' + '128'
                else:
                    if not inet:
                        inet = FamilyInet()
                        family.set_inet(inet)
                    addr = Address()
                    inet.add_address(addr)
                    lo_ip = ip + '/' + '32'
                addr.set_name(lo_ip)
                addr.set_comment(DMUtils.lo0_ip_comment(subnet))
            ri.add_interface(
                Interface(name="lo0." + ifl_num,
                          comment=DMUtils.lo0_ri_intf_comment(vn)))

        self.route_targets |= import_targets | export_targets