def add_bgp_ipv4_unicast_network(self, arg_asnum, arg_ip, arg_prefixlen):
bgp = Cisco_IOS_XR_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
instance_as_four_byte_as = instance_as.FourByteAs()
instance_as_four_byte_as.bgp_running = ydk.types.Empty()
instance_as_four_byte_as.as_ = arg_asnum
global_af = instance_as_four_byte_as.default_vrf.global_.global_afs.GlobalAf()
global_af.af_name = xr_ipv4_bgp_datatypes.BgpAddressFamilyEnum.ipv4_unicast
global_af.enable = ydk.types.Empty()
sourced_network = global_af.sourced_networks.SourcedNetwork()
sourced_network.network_addr = arg_ip
sourced_network.network_prefix = arg_prefixlen
global_af.sourced_networks.sourced_network.append(sourced_network)
instance_as_four_byte_as.default_vrf.global_.global_afs.global_af.append(global_af)
instance_as.four_byte_as.append(instance_as_four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
self.xr.ydk_crud.create(self.xr.ydk_provider, bgp)
def add_bgp_neighbor(self, arg_asnumber, arg_neighbor_ip, arg_remote_as, arg_update_source = None):
bgp = Cisco_IOS_XR_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
instance_as_four_byte_as = instance_as.FourByteAs()
instance_as_four_byte_as.bgp_running = ydk.types.Empty()
instance_as_four_byte_as.as_ = arg_asnumber
neighbor = instance_as_four_byte_as.default_vrf.bgp_entity.neighbors.Neighbor()
neighbor.neighbor_address = arg_neighbor_ip
neighbor.remote_as.as_xx = 0
neighbor.remote_as.as_yy = arg_remote_as
if(arg_update_source):
neighbor.update_source_interface = arg_update_source
instance_as_four_byte_as.default_vrf.bgp_entity.neighbors.neighbor.append(neighbor)
instance_as.four_byte_as.append(instance_as_four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
self.xr.ydk_crud.create(self.xr.ydk_provider, bgp)
def add_ipv4_unicast_SAFI_to_bgp_neighbor(self, arg_asnumber, arg_neighbor_ip):
bgp = Cisco_IOS_XR_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
instance_as_four_byte_as = instance_as.FourByteAs()
instance_as_four_byte_as.bgp_running = ydk.types.Empty()
instance_as_four_byte_as.as_ = arg_asnumber
neighbor = instance_as_four_byte_as.default_vrf.bgp_entity.neighbors.Neighbor()
neighbor.neighbor_address = arg_neighbor_ip
neighbor_af = neighbor.neighbor_afs.NeighborAf()
neighbor_af.af_name = Cisco_IOS_XR_ipv4_bgp_datatypes.BgpAddressFamilyEnum.ipv4_unicast
neighbor_af.activate = ydk.types.Empty()
neighbor.neighbor_afs.neighbor_af.append(neighbor_af)
instance_as_four_byte_as.default_vrf.bgp_entity.neighbors.neighbor.append(neighbor)
instance_as.four_byte_as.append(instance_as_four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
self.xr.ydk_crud.create(self.xr.ydk_provider, bgp)
def deploy_bgp_neighbor(kafka_consumer, provider, crud, router, neighbor):
"""Configure and verify BGP neighbor"""
# BGP neighbor configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
configure_bgp_neighbor(bgp,
local_as=router["as"],
neighbor_address=neighbor["address"],
remote_as=neighbor["as"])
# create configuration on NETCONF device
crud.create(provider, bgp)
return verify_bgp_neighbor(kafka_consumer,
node=router["name"],
neighbor_address=neighbor["address"],
timeout=VALIDATION_TIMEOUT)
def odl_run(crud_service, session):
bgp = xr_bgp.Bgp()
instance = bgp.Instance()
bgp.instance.append(instance)
instance.instance_name = 'test'
instance_as = xr_bgp.Bgp.Instance.InstanceAs()
instance_as.as_ = 65001
instance.instance_as.append(instance_as)
four_byte_as = xr_bgp.Bgp.Instance.InstanceAs.FourByteAs()
four_byte_as.as_ = 65001
four_byte_as.bgp_running = Empty()
instance_as.four_byte_as.append(four_byte_as)
# global address family
global_af = four_byte_as.DefaultVrf.Global_.GlobalAfs.GlobalAf()
global_af.af_name = xr_bgp_types.BgpAddressFamilyEnum.ipv4_unicast
global_af.enable = Empty()
four_byte_as.default_vrf.global_.global_afs.global_af.append(global_af)
# configure IBGP neighbor group
neighbor_group = four_byte_as.DefaultVrf.BgpEntity.NeighborGroups.NeighborGroup(
)
neighbor_group.neighbor_group_name = 'IBGP'
neighbor_group.create = Empty()
# remote AS
neighbor_group.remote_as.as_xx = 0
neighbor_group.remote_as.as_yy = 65001
neighbor_group.update_source_interface = 'Loopback0'
four_byte_as.default_vrf.bgp_entity.neighbor_groups.neighbor_group.append(
neighbor_group)
# ipv4 unicast
neighbor_group_af = neighbor_group.NeighborGroupAfs.NeighborGroupAf()
neighbor_group_af.af_name = xr_bgp_types.BgpAddressFamilyEnum.ipv4_unicast
neighbor_group_af.activate = Empty()
neighbor_group.neighbor_group_afs.neighbor_group_af.append(
neighbor_group_af)
# configure IBGP neighbor
neighbor = four_byte_as.DefaultVrf.BgpEntity.Neighbors.Neighbor()
neighbor.neighbor_address = '172.16.255.2'
neighbor.neighbor_group_add_member = 'IBGP'
four_byte_as.default_vrf.bgp_entity.neighbors.neighbor.append(neighbor)
crud_service.create(provider.get_node_provider('xr'), bgp)
def deploy_bgp_vrf(kafka_consumer, provider, crud, router, vrf):
"""Configure and verify BGP VRF"""
# BGP VRF configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
configure_bgp_vrf(bgp,
local_as=router["as"],
vrf_name=vrf["name"],
route_distinguisher=vrf["route-distinguisher"])
# create configuration on NETCONF device
crud.create(provider, bgp)
return verify_bgp_vrf(kafka_consumer,
node=router["name"],
vrf_name=vrf["name"],
address=vrf["prefix"]["address"],
prefix_length=vrf["prefix"]["length"],
timeout=VALIDATION_TIMEOUT)
def create_bgp_process(self, arg_asnum):
bgp = Cisco_IOS_XR_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
instance_as_four_byte_as = instance_as.FourByteAs()
instance_as_four_byte_as.bgp_running = ydk.types.Empty()
instance_as_four_byte_as.as_ = arg_asnum
instance_as.four_byte_as.append(instance_as_four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
self.xr.ydk_crud.create(self.xr.ydk_provider, bgp)
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
bgp = xr_ipv4_bgp_cfg.Bgp() # create object
config_bgp(bgp) # add object configuration
# encode and print object
print(codec.encode(provider, bgp))
exit()
# End of script
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
# BGP configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
configure_bgp_neighbor(bgp, int(args.local_as), args.neighbor_address,
int(args.remote_as))
# create configuration on NETCONF device
crud.create(provider, bgp)
sys.exit()
# End of script
def create_l3_service(request, nc_provider):
# create CRUD service
crud = CRUDService()
# create codec provider
codec_provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
# interface configuration
interface_name = request['interface-name']
# create ifmgr obj
if_cfg = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration()
if_cfg.active = "act"
if_cfg.interface_name = interface_name
if_cfg.interface_mode_non_physical = xr_ifmgr_cfg.InterfaceModeEnum.default
if_cfg.statistics = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Statistics(
)
if_cfg.statistics.load_interval = 30
if_cfg.ipv4_network = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
)
if_cfg.ipv4_network.addresses = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses()
primary_address = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses().Primary()
primary_address.address = request['intf-ip']
primary_address.netmask = "255.255.255.252"
if_cfg.ipv4_network.addresses.primary = primary_address
if_cfg.vlan_sub_configuration = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration()
if_cfg.vlan_sub_configuration.vlan_identifier = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration().VlanIdentifier()
if_cfg.vlan_sub_configuration.vlan_identifier.first_tag = int(
request['vlan-id'])
encap_type = xr_eth_infra_dt.Vlan.vlan_type_dot1q
if_cfg.vlan_sub_configuration.vlan_identifier.vlan_type = encap_type
the_xml = codec.encode(codec_provider, if_cfg)
# logging.info(the_xml)
# create the interface configurations add the if_cfg to it
if_cfgs = xr_ifmgr_cfg.InterfaceConfigurations()
if_cfgs.interface_configuration.append(if_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, if_cfgs)
elif request['delete-config'] == 'on':
crud.delete(nc_provider, if_cfg)
# global configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
four_byte_as = instance_as.FourByteAs()
four_byte_as.as_ = int(request['bgp-as'])
four_byte_as.bgp_running = Empty()
# global address family
global_af = four_byte_as.default_vrf.global_.global_afs.GlobalAf()
global_af.af_name = xr_ipv4_bgp_datatypes.BgpAddressFamily.ipv4_unicast
global_af.enable = Empty()
global_af.sourced_networks = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks()
network = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks().SourcedNetwork()
addr_parsed = request['intf-ip'].split('.')
addr = addr_parsed[0] + "." + addr_parsed[1] + "." + addr_parsed[2] + ".0"
network.network_addr = addr
network.network_prefix = int(request['mask'])
global_af.sourced_networks.sourced_network.append(network)
four_byte_as.default_vrf.global_.global_afs.global_af.append(global_af)
instance_as.four_byte_as.append(four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
the_xml = codec.encode(codec_provider, bgp)
logging.info(the_xml)
if request['delete-config'] == 'off':
crud.create(nc_provider, bgp)
elif request['delete-config'] == 'on':
bgp_instance = bgp.instance['default']
sourced = bgp.instance['default'].instance_as['0'].four_byte_as[
request['bgp-as']].default_vrf.global_.global_afs.global_af[
'ipv4-unicast'].sourced_networks
sn = sourced.sourced_network[addr, int(request['mask'])]
sn.yfilter = YFilter.delete
crud.update(nc_provider, bgp)
return
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
bmp_servers = xr_ipv4_bgp_cfg.BmpServers() # create object
config_bmp_servers(bmp_servers) # add object configuration
# encode and print object
# print(codec.encode(provider, bmp_servers))
provider.close()
exit()
# End of script
