def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl,
auth_host=self._args.openstack_ip)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
#self.phy_obj = self._vnc_lib.physical_routers_list()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.del_physical_device()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
if self._args.oper != "add":
conf_obj=GlobalVrouterConfig()
else :
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
linklocal_obj=LinklocalServiceEntryType(
linklocal_service_name=self._args.linklocal_service_name,
linklocal_service_ip=self._args.linklocal_service_ip,
linklocal_service_port=self._args.linklocal_service_port,
ip_fabric_DNS_service_name=self._args.ipfabric_dns_service_name,
ip_fabric_service_port=self._args.ipfabric_service_port)
if self._args.ipfabric_service_ip:
linklocal_obj.ip_fabric_service_ip=[self._args.ipfabric_service_ip]
try:
if self._args.oper == "add":
linklocal_services_obj = LinklocalServicesTypes([linklocal_obj])
conf_obj = GlobalVrouterConfig(linklocal_services=linklocal_services_obj)
result = self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created! Updating the object."
sleep(5)
current_config = self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config', 'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
if current_linklocal is None:
obj = {'linklocal_service_entry': []}
else:
obj = current_linklocal.__dict__
new_linklocal=[]
for key, value in obj.iteritems():
found=False
for vl in value:
entry = vl.__dict__
if ('linklocal_service_name' in entry and
entry['linklocal_service_name'] == self._args.linklocal_service_name):
if self._args.oper == "add":
new_linklocal.append(linklocal_obj)
found=True
else:
new_linklocal.append(vl)
if not found and self._args.oper == "add":
new_linklocal.append(linklocal_obj)
obj[key] = new_linklocal
conf_obj=GlobalVrouterConfig(linklocal_services=obj)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc_lib = self._vnc_lib
if self._args.op is None or self._args.op == 'add_basic':
router_external = False
if self._args.public_vrf_test is not None and self._args.public_vrf_test == 'True':
router_external = True
vxlan = None
if self._args.vxlan is not None:
vxlan = self._args.vxlan
self.add_physical_router_config(router_external, vxlan)
elif self._args.op == 'delete_basic':
print 'calling delete_physical_router_config\n'
self.delete_physical_router_config()
elif self._args.op == 'delete_fip_test':
print 'calling delete_physical_router_config: fip_test\n'
self.delete_bms_config()
elif self._args.op == 'fip_test':
print 'calling add_physical_router_config: fip_test\n'
self.add_bms_config()
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
global_vrouter_fq_name = ['default-global-system-config',
'default-global-vrouter-config']
if self._args.oper == "add":
encap_obj = EncapsulationPrioritiesType(
encapsulation=self._args.encap_priority.split(","))
conf_obj = GlobalVrouterConfig(encapsulation_priorities=encap_obj,
vxlan_network_identifier_mode=self._args.vxlan_vn_id_mode,
fq_name=global_vrouter_fq_name)
try:
result = self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s' % result
except RefsExistError:
print "Already created! Updating the object."
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s' % result
return
elif self._args.oper != "add":
encap_obj = EncapsulationPrioritiesType(encapsulation=[])
conf_obj = GlobalVrouterConfig(encapsulation_priorities=encap_obj,
fq_name=global_vrouter_fq_name)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.router_asn and not self._args.oper:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
# Update global system config also with this ASN
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.set_autonomous_system(self._args.router_asn)
if self._args.ibgp_auto_mesh is not None:
gsc_obj.set_ibgp_auto_mesh(self._args.ibgp_auto_mesh)
if self._args.set_graceful_restart_parameters == True:
gr_params = GracefulRestartParametersType()
gr_params.set_restart_time(
int(self._args.graceful_restart_time))
gr_params.set_long_lived_restart_time(
int(self._args.long_lived_graceful_restart_time))
gr_params.set_end_of_rib_timeout(
int(self._args.end_of_rib_timeout))
gr_params.set_enable(self._args.graceful_restart_enable)
gr_params.set_bgp_helper_enable(
self._args.graceful_restart_bgp_helper_enable)
gr_params.set_xmpp_helper_enable(
self._args.graceful_restart_xmpp_helper_enable)
gsc_obj.set_graceful_restart_parameters(gr_params)
self._vnc_lib.global_system_config_update(gsc_obj)
return
bp_obj = BgpProvisioner(
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip, self._args.api_server_port,
api_server_use_ssl=self._args.api_server_use_ssl,
use_admin_api=self._args.use_admin_api)
if self._args.oper == 'add':
bp_obj.add_bgp_router('control-node', self._args.host_name,
self._args.host_ip, self._args.router_asn,
self._args.address_families, self._args.md5)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.host_name)
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._prov_info = self._read_provision_data()
prov_info = self._prov_info
self._bgp_addr_fams = AddressFamilies(['inet-vpn'])
self._bgp_sess_attrs = [
BgpSessionAttributes(address_families=self._bgp_addr_fams)
]
self._bgp_sessions = [BgpSession(attributes=self._bgp_sess_attrs)]
self._bgp_peering_attrs = BgpPeeringAttributes(
session=self._bgp_sessions)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
vnc_lib = self._vnc_lib
gsc_obj = vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.set_autonomous_system(prov_info['bgp-asn'])
if 'ibgp-auto-mesh' in prov_info:
gsc_obj.set_ibgp_auto_mesh(prov_infoi['ibgp-auto-mesh'])
vnc_lib.global_system_config_update(gsc_obj)
self._global_system_config_obj = gsc_obj
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
self._fab_rt_inst_obj = rt_inst_obj
for host in prov_info['hosts']:
for role in host['roles']:
if role['type'] == 'bgp':
self.add_bgp_router(host['name'], host['ip'])
elif role['type'] == 'compute':
self.add_vrouter(host['name'], host['ip'])
def __init__(self, user, password, tenant, api_server_ip, api_server_port,
api_server_use_ssl=False, use_admin_api=False,
sub_cluster_name=None, peer_list=None):
self._admin_user = user
self._admin_password = password
self._admin_tenant_name = tenant
self._api_server_ip = api_server_ip
self._api_server_port = api_server_port
self._api_server_use_ssl = api_server_use_ssl
self._sub_cluster_name = sub_cluster_name
self._peer_list = peer_list
self._vnc_lib = VncApiAdmin(
use_admin_api, self._admin_user, self._admin_password,
self._admin_tenant_name,
self._api_server_ip,
self._api_server_port, '/',
api_server_use_ssl=self._api_server_use_ssl)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
rt_inst_obj = self._vnc_lib.routing_instance_read(
fq_name=['default-domain', 'default-project',
'ip-fabric', '__default__'])
self._fab_rt_inst_obj = rt_inst_obj
if self._args.oper == 'add':
self.add_vrouter()
if not self._args.disable_vhost_vmi:
self.add_vhost0_vmi()
elif self._args.oper == 'del':
self.del_vhost0_vmi()
self.del_vrouter()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
#import pdb;pdb.set_trace()
vxlan_id = self._args.vxlan_id
vn_name = self._args.vn_name
forwarding_mode = self._args.forwarding_mode
project_fq_name_str = self._args.project_fq_name
project_fq_name = project_fq_name_str.split(':')
#Figure out VN
vni_list = self._vnc_lib.virtual_networks_list(
parent_fq_name = project_fq_name)['virtual-networks']
found = False
for vni_record in vni_list:
if (vni_record['fq_name'][0] == project_fq_name[0] and
vni_record['fq_name'][1] == project_fq_name[1] and
vni_record['fq_name'][2] == vn_name):
vni_obj = self._vnc_lib.virtual_network_read(
id = vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties() or VirtualNetworkType()
if (vxlan_id is not None):
vni_obj_properties.set_vxlan_network_identifier(int(vxlan_id))
if (forwarding_mode is not None):
vni_obj_properties.set_forwarding_mode(forwarding_mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
self._vnc_lib.virtual_network_update(vni_obj)
found = True
if not found:
print "No Virtual Network %s" %(vn_name)
sys.exit(1)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
peer_list = self._args.peer_list.split(',')
else:
peer_list = None
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api, self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name, self._args.api_server_ip,
self._args.api_server_port, '/', self._args.api_server_use_ssl)
self.add_bgp_router()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.delete_physical_device()
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc = self._vnc_lib
gsc_uuid = vnc.global_system_configs_list(
)['global-system-configs'][0]['uuid']
gsc = vnc.global_system_config_read(id=gsc_uuid)
if hasattr(self._args, 'add'):
print('Add -> ', ', '.join(self._args.add))
g = GlobalSystemConfig()
g.add_user_defined_log_statistics(
UserDefinedLogStat(*self._args.add))
vnc.global_system_config_update(g)
elif hasattr(self._args, 'delete'):
print('Delete -> ', ', '.join(self._args.delete))
if gsc.user_defined_log_statistics:
gsc.user_defined_log_statistics.statlist = [
x for x in gsc.user_defined_log_statistics.statlist
if x.name not in self._args.delete
]
gsc.set_user_defined_log_statistics(
gsc.user_defined_log_statistics)
vnc.global_system_config_update(gsc)
elif hasattr(self._args, 'list'):
print('ls -> ', ', '.join(self._args.list))
print('Configured:')
if gsc.user_defined_log_statistics:
for x in gsc.user_defined_log_statistics.statlist:
if self._chk2print(x.name):
print('Name: "%s", Pattern: "%s"' %
(x.name, x.pattern))
def __init__(self,
user,
password,
tenant,
api_server_ip,
api_server_port,
api_server_use_ssl=False,
use_admin_api=False):
self._admin_user = user
self._admin_password = password
self._admin_tenant_name = tenant
self._api_server_ip = api_server_ip
self._api_server_port = api_server_port
self._api_server_use_ssl = api_server_use_ssl
self._vnc_lib = VncApiAdmin(
use_admin_api,
self._admin_user,
self._admin_password,
self._admin_tenant_name,
self._api_server_ip,
self._api_server_port,
'/',
api_server_use_ssl=self._api_server_use_ssl)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
if self._args.oper == 'add':
self.add_analytics_alarm_node()
elif self._args.oper == 'del':
self.del_analytics_alarm_node()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
class VncProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc_lib = self._vnc_lib
if self._args.op is None or self._args.op == 'add_basic':
router_external = False
if self._args.public_vrf_test is not None and self._args.public_vrf_test == 'True':
router_external = True
vxlan = None
if self._args.vxlan is not None:
vxlan = self._args.vxlan
self.add_physical_router_config(router_external, vxlan)
elif self._args.op == 'delete_basic':
print 'calling delete_physical_router_config\n'
self.delete_physical_router_config()
elif self._args.op == 'delete_fip_test':
print 'calling delete_physical_router_config: fip_test\n'
self.delete_bms_config()
elif self._args.op == 'fip_test':
print 'calling add_physical_router_config: fip_test\n'
self.add_bms_config()
# end __init__
def _get_ip_fabric_ri_obj(self):
# TODO pick fqname hardcode from common
rt_inst_obj = self._vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
return rt_inst_obj
# end _get_ip_fabric_ri_obj
def create_router(self, name, mgmt_ip, password):
bgp_router = BgpRouter(name, parent_obj=self._get_ip_fabric_ri_obj())
params = BgpRouterParams()
params.address = mgmt_ip
params.address_families = AddressFamilies(
['route-target', 'inet-vpn', 'e-vpn', 'inet6-vpn'])
params.autonomous_system = 64512
params.vendor = 'mx'
params.identifier = mgmt_ip
bgp_router.set_bgp_router_parameters(params)
self._vnc_lib.bgp_router_create(bgp_router)
pr = PhysicalRouter(name)
pr.physical_router_management_ip = mgmt_ip
pr.physical_router_vendor_name = 'juniper'
pr.physical_router_product_name = 'mx'
pr.physical_router_vnc_managed = True
uc = UserCredentials('root', password)
pr.set_physical_router_user_credentials(uc)
pr.set_bgp_router(bgp_router)
pr_id = self._vnc_lib.physical_router_create(pr)
return bgp_router, pr
def add_physical_router_config(self, router_external=False, vxlan=None):
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is None:
ipam_obj = NetworkIpam('ipam1')
self._vnc_lib.network_ipam_create(ipam_obj)
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn1'])
except NoIdError:
pass
if vn1_obj is None:
vn1_obj = VirtualNetwork('vn1')
if router_external == True:
vn1_obj.set_router_external(True)
if vxlan is not None:
vn1_obj_properties = VirtualNetworkType()
vn1_obj_properties.set_vxlan_network_identifier(int(vxlan))
vn1_obj.set_virtual_network_properties(vn1_obj_properties)
vn1_obj.add_network_ipam(
ipam_obj,
VnSubnetsType([IpamSubnetType(SubnetType("10.0.0.0", 24))]))
vn1_uuid = self._vnc_lib.virtual_network_create(vn1_obj)
pr = None
try:
pr = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'a7-mx-80'])
except NoIdError:
pass
if pr is None:
bgp_router, pr = self.create_router('a7-mx-80', '10.84.63.133',
'abc123')
pr.set_virtual_network(vn1_obj)
self._vnc_lib.physical_router_update(pr)
pi = None
try:
pi = self._vnc_lib.physical_interface_read(fq_name=[
u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5'
])
except NoIdError:
pass
if pi is None:
pi = PhysicalInterface('ge-1/0/5', parent_obj=pr)
pi_id = self._vnc_lib.physical_interface_create(pi)
fq_name = ['default-domain', 'default-project', 'vmi1']
default_project = self._vnc_lib.project_read(
fq_name=[u'default-domain', u'default-project'])
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is None:
vmi = VirtualMachineInterface(fq_name=fq_name,
parent_type='project')
vmi.set_virtual_network(vn1_obj)
self._vnc_lib.virtual_machine_interface_create(vmi)
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[
u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5',
u'ge-1/0/5.0'
])
except NoIdError:
pass
if li is None:
li = LogicalInterface('ge-1/0/5.0', parent_obj=pi)
li.vlan_tag = 100
li.set_virtual_machine_interface(vmi)
li_id = self._vnc_lib.logical_interface_create(li)
# end
def delete_physical_router_config(self):
print 'delete_physical_router_config\n'
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[
u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5',
u'ge-1/0/5.0'
])
except NoIdError:
pass
if li is not None:
self._vnc_lib.logical_interface_delete(li.get_fq_name())
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is not None:
self._vnc_lib.virtual_machine_interface_delete(vmi.get_fq_name())
pi = None
try:
pi = self._vnc_lib.physical_interface_read(fq_name=[
u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5'
])
except NoIdError:
pass
if pi is not None:
pi_id = self._vnc_lib.physical_interface_delete(pi.get_fq_name())
pr = None
try:
pr = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'a7-mx-80'])
except NoIdError:
pass
if pr is not None:
self._vnc_lib.physical_router_delete(pr.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[
u'default-domain', u'default-project', u'ip-fabric',
u'__default__', u'a7-mx-80'
])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn1'])
except NoIdError:
pass
if vn1_obj is not None:
vn1_uuid = self._vnc_lib.virtual_network_delete(
vn1_obj.get_fq_name())
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is not None:
self._vnc_lib.network_ipam_delete(ipam_obj.get_fq_name())
# end
#python provision_physical_router.py --api_server_ip 127.0.0.1 --api_server_port 8082 --admin_user admin --admin_password c0ntrail123 --admin_tenant_name default-domain --op delete_fip_test
def delete_bms_config(self):
pr = None
try:
pr = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'a2-mx-80'])
except NoIdError:
pass
if pr is not None:
self._vnc_lib.physical_router_delete(pr.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[
u'default-domain', u'default-project', u'ip-fabric',
u'__default__', u'a2-mx-80'
])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
#TOR
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[
u'default-global-system-config', u'qfx-1', u'xe-0/0/0',
u'xe-0/0/0.0'
])
except NoIdError:
pass
if li is not None:
li_id = self._vnc_lib.logical_interface_delete(li.get_fq_name())
ip_obj1 = None
try:
ip_obj1 = self._vnc_lib.instance_ip_read(fq_name=[u'inst-ip-1'])
except NoIdError:
pass
if ip_obj1 is not None:
self._vnc_lib.instance_ip_delete(ip_obj1.get_fq_name())
fip_obj = None
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name=[
u'default-domain', u'default-project', u'vn-public',
u'vn_public_fip_pool', u'fip-1'
])
except NoIdError:
pass
if fip_obj is not None:
self._vnc_lib.floating_ip_delete(fip_obj.get_fq_name())
fip_pool = None
try:
fip_pool = self._vnc_lib.floating_ip_pool_read(fq_name=[
u'default-domain', u'default-project', u'vn-public',
u'vn_public_fip_pool'
])
except NoIdError:
pass
if fip_pool is not None:
self._vnc_lib.floating_ip_pool_delete(fip_pool.get_fq_name())
pi_tor = None
try:
pi_tor = self._vnc_lib.physical_interface_read(fq_name=[
u'default-global-system-config', u'qfx-1', u'xe-0/0/0'
])
except NoIdError:
pass
if pi_tor is not None:
pi_tor_id = self._vnc_lib.physical_interface_delete(
pi_tor.get_fq_name())
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is not None:
self._vnc_lib.virtual_machine_interface_delete(vmi.get_fq_name())
pr_tor = None
try:
pr_tor = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'qfx-1'])
except NoIdError:
pass
if pr_tor is not None:
self._vnc_lib.physical_router_delete(pr_tor.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[
u'default-domain', u'default-project', u'ip-fabric',
u'__default__', u'qfx-1'
])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
vn2_obj = None
try:
vn2_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn-public'])
except NoIdError:
pass
if vn2_obj is not None:
self._vnc_lib.virtual_network_delete(vn2_obj.get_fq_name())
ipam2_obj = None
try:
ipam2_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam2'])
except NoIdError:
pass
if ipam2_obj is not None:
self._vnc_lib.network_ipam_delete(ipam2_obj.get_fq_name())
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn-private'])
except NoIdError:
pass
if vn1_obj is not None:
vn1_uuid = self._vnc_lib.virtual_network_delete(
vn1_obj.get_fq_name())
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is not None:
self._vnc_lib.network_ipam_delete(ipam_obj.get_fq_name())
# end
# python provision_physical_router.py --api_server_ip 127.0.0.1 --api_server_port 8082 --admin_user admin --admin_password c0ntrail123 --admin_tenant_name default-domain --op fip_test
def add_bms_config(self):
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is None:
ipam_obj = NetworkIpam('ipam1')
self._vnc_lib.network_ipam_create(ipam_obj)
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn-private'])
except NoIdError:
pass
if vn1_obj is None:
vn1_obj = VirtualNetwork('vn-private')
vn1_obj.add_network_ipam(
ipam_obj,
VnSubnetsType([IpamSubnetType(SubnetType("10.0.0.0", 24))]))
vn1_uuid = self._vnc_lib.virtual_network_create(vn1_obj)
pr = None
try:
pr = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'a2-mx-80'])
except NoIdError:
pass
if pr is None:
bgp_router, pr = self.create_router('a2-mx-80', '10.84.7.253',
'abc123')
pr.add_virtual_network(vn1_obj)
junos_service_ports = JunosServicePorts()
junos_service_ports.service_port.append("si-0/0/0")
pr.set_physical_router_junos_service_ports(junos_service_ports)
pr.physical_router_vendor_name = 'juniper'
pr.physical_router_product_name = 'mx'
pr.physical_router_vnc_managed = True
self._vnc_lib.physical_router_update(pr)
#TOR
pr_tor = None
try:
pr_tor = self._vnc_lib.physical_router_read(
fq_name=[u'default-global-system-config', u'qfx-1'])
except NoIdError:
pass
if pr_tor is None:
bgp_router2, pr_tor = self.create_router('qfx-1', '2.2.2.2',
'abc123')
pr_tor.set_virtual_network(vn1_obj)
pr_tor.physical_router_vendor_name = 'juniper'
pr_tor.physical_router_product_name = 'qfx'
pr_tor.physical_router_vnc_managed = False
self._vnc_lib.physical_router_update(pr_tor)
pi_tor = None
try:
pi_tor = self._vnc_lib.physical_interface_read(fq_name=[
u'default-global-system-config', u'qfx-1', u'xe-0/0/0'
])
except NoIdError:
pass
if pi_tor is None:
pi_tor = PhysicalInterface('xe-0/0/0', parent_obj=pr_tor)
pi_tor_id = self._vnc_lib.physical_interface_create(pi_tor)
fq_name = ['default-domain', 'default-project', 'vmi1']
default_project = self._vnc_lib.project_read(
fq_name=[u'default-domain', u'default-project'])
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is None:
vmi = VirtualMachineInterface(fq_name=fq_name,
parent_type='project')
vmi.set_virtual_network(vn1_obj)
self._vnc_lib.virtual_machine_interface_create(vmi)
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[
u'default-global-system-config', u'qfx-1', u'xe-0/0/0',
u'xe-0/0/0.0'
])
except NoIdError:
pass
if li is None:
li = LogicalInterface('xe-0/0/0.0', parent_obj=pi_tor)
li.set_virtual_machine_interface(vmi)
li_id = self._vnc_lib.logical_interface_create(li)
ip_obj1 = None
try:
ip_obj1 = self._vnc_lib.instance_ip_read(fq_name=[u'inst-ip-1'])
except NoIdError:
pass
if ip_obj1 is None:
ip_obj1 = InstanceIp(name='inst-ip-1')
ip_obj1.set_virtual_machine_interface(vmi)
ip_obj1.set_virtual_network(vn1_obj)
ip_id1 = self._vnc_lib.instance_ip_create(ip_obj1)
ip_obj1 = self._vnc_lib.instance_ip_read(id=ip_id1)
ip_addr1 = ip_obj1.get_instance_ip_address()
ipam2_obj = None
try:
ipam2_obj = self._vnc_lib.network_ipam_read(
fq_name=[u'default-domain', u'default-project', u'ipam2'])
except NoIdError:
pass
if ipam2_obj is None:
ipam2_obj = NetworkIpam('ipam2')
self._vnc_lib.network_ipam_create(ipam2_obj)
vn2_obj = None
try:
vn2_obj = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'vn-public'])
except NoIdError:
pass
if vn2_obj is None:
vn2_obj = VirtualNetwork('vn-public')
vn2_obj.set_router_external(True)
vn2_obj.add_network_ipam(
ipam_obj,
VnSubnetsType([IpamSubnetType(SubnetType("192.168.7.0", 24))]))
vn2_uuid = self._vnc_lib.virtual_network_create(vn2_obj)
pr.add_virtual_network(vn2_obj)
self._vnc_lib.physical_router_update(pr)
fip_pool = None
try:
fip_pool = self._vnc_lib.floating_ip_pool_read(fq_name=[
u'default-domain', u'default-project', u'vn-public',
u'vn_public_fip_pool'
])
except NoIdError:
pass
if fip_pool is None:
fip_pool_name = 'vn_public_fip_pool'
fip_pool = FloatingIpPool(fip_pool_name, vn2_obj)
self._vnc_lib.floating_ip_pool_create(fip_pool)
fip_obj = None
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name=[
u'default-domain', u'default-project', u'vn-public',
u'vn_public_fip_pool', 'fip-1'
])
except NoIdError:
pass
if fip_obj is None:
fip_obj = FloatingIp("fip-1", fip_pool)
fip_obj.set_virtual_machine_interface(vmi)
default_project = self._vnc_lib.project_read(
fq_name=[u'default-domain', u'default-project'])
fip_obj.set_project(default_project)
fip_uuid = self._vnc_lib.floating_ip_create(fip_obj)
# end
def _parse_args(self, args_str):
'''
Eg. python provision_physical_router.py
--api_server_ip 127.0.0.1
--api_server_port 8082
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
#'public_vn_name': 'default-domain:'
#'default-project:default-virtual-network',
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--admin_user",
help="Name of keystone admin user",
required=True)
parser.add_argument("--admin_password",
help="Password of keystone admin user",
required=True)
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user",
required=True)
parser.add_argument(
"--op",
help="operation (add_basic, delete_basic, fip_test)",
required=True)
parser.add_argument("--public_vrf_test",
help="operation (False, True)",
required=False)
parser.add_argument("--vxlan", help="vxlan identifier", required=False)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class MetadataProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
linklocal_obj=LinklocalServiceEntryType(
linklocal_service_name=self._args.linklocal_service_name,
linklocal_service_ip=self._args.linklocal_service_ip,
linklocal_service_port=self._args.linklocal_service_port,
ip_fabric_DNS_service_name=self._args.ipfabric_dns_service_name,
ip_fabric_service_port=self._args.ipfabric_service_port)
if self._args.ipfabric_service_ip:
linklocal_obj.ip_fabric_service_ip=[self._args.ipfabric_service_ip]
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
linklocal_services_obj=LinklocalServicesTypes([linklocal_obj])
conf_obj=GlobalVrouterConfig(linklocal_services=linklocal_services_obj)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
current_linklocal=current_config.get_linklocal_services()
if current_linklocal is None:
obj = {'linklocal_service_entry': []}
else:
obj = current_linklocal.__dict__
new_linklocal=[]
for key, value in obj.iteritems():
found=False
for vl in value:
entry = vl.__dict__
if ('linklocal_service_name' in entry and
entry['linklocal_service_name'] == self._args.linklocal_service_name):
if self._args.oper == "add":
new_linklocal.append(linklocal_obj)
found=True
else:
new_linklocal.append(vl)
if not found and self._args.oper == "add":
new_linklocal.append(linklocal_obj)
obj[key] = new_linklocal
conf_obj=GlobalVrouterConfig(linklocal_services=obj)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_metadata.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--linklocal_service_name name
--linklocal_service_ip 1.2.3.4
--linklocal_service_port 1234
--ipfabric_dns_service_name fabric_server_name
--ipfabric_service_ip 10.1.1.1
--ipfabric_service_port 5775
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'linklocal_service_name': '',
'linklocal_service_ip': '',
'linklocal_service_port': 0,
'ipfabric_dns_service_name': '',
'ipfabric_service_ip': [],
'ipfabric_service_port': 0,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--linklocal_service_name", help="Service Name")
parser.add_argument(
"--linklocal_service_ip", help="Link Local Service IP")
parser.add_argument(
"--linklocal_service_port", type=int, help="Link Local Service Port")
parser.add_argument(
"--ipfabric_dns_service_name", help="IP Fabric DNS Service Name")
parser.add_argument(
"--ipfabric_service_ip", help="IP Fabric Service IP")
parser.add_argument(
"--ipfabric_service_port", type=int, help="IP Fabric Service Port")
parser.add_argument(
"--oper", default='add', help="Provision operation to be done(add or delete)")
parser.add_argument(
"--admin_tenant_name", help="Tenant to create the Link Local Service")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
if not self._args.linklocal_service_name:
parser.error('linklocal_service_name is required')
class GlobalVrouterConfigProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
try:
current_config = self._vnc_lib.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
result = self._vnc_lib.global_vrouter_config_create(
conf_obj)
print 'Created.UUID is %s' % (result)
return
except RefsExistError:
print "Already created!"
if self._args.oper != "add":
conf_obj = GlobalVrouterConfig()
else:
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s' % (result)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_global_vrouter_config.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--flow_export_rate 10
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--flow_export_rate",
type=int,
required=True,
help="Flow export rate to the collector")
parser.add_argument(
"--oper",
default='add',
choices=['add', 'delete'],
help="Provision operation to be done(add or delete)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class GlobalVrouterConfigProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
port_trans_pool_list = []
if self._args.snat_list:
port=None
protocol=None
for proto_port in self._args.snat_list:
port_count=''
port_range_obj=None
protocol = proto_port.split(':')[0]
port = proto_port.split(':')[1]
if '-' in port:
port_range_obj = PortType(start_port=int(port.split('-')[0]),
end_port=int(port.split('-')[1]))
else:
port_count = port
port_trans_pool_obj = PortTranslationPool(protocol = protocol,
port_range = port_range_obj,
port_count = port_count)
port_trans_pool_list.append(port_trans_pool_obj)
port_trans_pools_obj = PortTranslationPools(port_trans_pool_list)
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(port_trans_pools_obj)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
existing_snat_pools = current_config.get_port_translation_pools()
if not existing_snat_pools:
existing_snat_pools = PortTranslationPools([])
if port_trans_pool_list:
for snat_pool in port_trans_pool_list:
if not self.check_dup_snat_pool(snat_pool, existing_snat_pools):
existing_snat_pools.add_port_translation_pool(snat_pool)
if self._args.oper != "add":
conf_obj=GlobalVrouterConfig()
else:
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(existing_snat_pools)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
# end __init__
def check_dup_snat_pool(self, snat_pool, existing_snat_pools):
for pool_obj in existing_snat_pools.get_port_translation_pool():
if snat_pool.get_port_count() and pool_obj.get_port_count():
if snat_pool.get_port_count() == pool_obj.get_port_count() and \
snat_pool.get_protocol() == pool_obj.get_protocol():
return True
elif snat_pool.get_port_range() and pool_obj.get_port_range():
if snat_pool.get_protocol() == pool_obj.get_protocol() and \
snat_pool.get_port_range().start_port == pool_obj.get_port_range().start_port and \
snat_pool.get_port_range().end_port == pool_obj.get_port_range().end_port:
return True
return False
def _parse_args(self, args_str):
'''
Eg. python provision_global_vrouter_config.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--flow_export_rate 10
--oper <add | delete>
--snat_list tcp:6000-7000 udp:500
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'snat_list': None
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--flow_export_rate", type=int, required=True,
help="Flow export rate to the collector")
parser.add_argument(
"--oper", default='add', choices=['add', 'delete'],
help="Provision operation to be done(add or delete)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenant name for keystone admin user")
parser.add_argument(
"--snat_list", help="Protocol port range or port count list for distributed snat",
nargs='+', type=str)
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.user,
self._args.password,
self._args.tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
prefix = self._args.prefix
vmi_id_got = self._args.virtual_machine_interface_id
route_table_name = self._args.route_table_name
try:
ip_nw = IPNetwork(prefix)
except AddrFormatError:
print('Invalid ip address format')
sys.exit(1)
project_fq_name_str = 'default-domain:' + self._args.tenant_name
project_fq_name = project_fq_name_str.split(':')
project_obj = self._vnc_lib.project_read(fq_name=project_fq_name)
route_table = RouteTableType(route_table_name)
route_table.set_route([])
intf_route_table = InterfaceRouteTable(
interface_route_table_routes=route_table,
parent_obj=project_obj,
name=route_table_name)
try:
route_table_obj = self._vnc_lib.interface_route_table_read(
fq_name=intf_route_table.get_fq_name())
intf_route_table_id = route_table_obj.uuid
except NoIdError:
if self._args.oper == 'del':
print("Route table %s does not exist" % (route_table_name))
sys.exit(1)
print("Creating Route table")
intf_route_table_id = self._vnc_lib.interface_route_table_create(
intf_route_table)
intf_route_table_obj = self._vnc_lib.interface_route_table_read(
id=intf_route_table_id)
if self._args.oper == 'add':
intf_route_table_obj = self.add_route(intf_route_table_obj, prefix)
elif self._args.oper == 'del':
intf_route_table_obj = self.del_route(intf_route_table_obj, prefix)
self._vnc_lib.interface_route_table_update(intf_route_table_obj)
#Update the VMI Object now
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_id_got)
if self._args.oper == 'add':
vmi_obj.add_interface_route_table(intf_route_table_obj)
elif self._args.oper == 'del':
if self.is_route_table_empty(intf_route_table_obj):
vmi_obj.del_interface_route_table(intf_route_table_obj)
self._vnc_lib.virtual_machine_interface_update(vmi_obj)
class ControlProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
peer_list = self._args.peer_list.split(',')
else:
peer_list = None
if self._args.router_asn and not self._args.oper:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
# Update global system config also with this ASN
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.set_autonomous_system(self._args.router_asn)
if self._args.ibgp_auto_mesh is not None:
gsc_obj.set_ibgp_auto_mesh(self._args.ibgp_auto_mesh)
if self._args.set_graceful_restart_parameters == True:
gr_params = GracefulRestartParametersType()
gr_params.set_restart_time(
int(self._args.graceful_restart_time))
gr_params.set_long_lived_restart_time(
int(self._args.long_lived_graceful_restart_time))
gr_params.set_end_of_rib_timeout(
int(self._args.end_of_rib_timeout))
gr_params.set_enable(self._args.graceful_restart_enable)
gr_params.set_bgp_helper_enable(
self._args.graceful_restart_bgp_helper_enable)
gr_params.set_xmpp_helper_enable(
self._args.graceful_restart_xmpp_helper_enable)
gsc_obj.set_graceful_restart_parameters(gr_params)
self._vnc_lib.global_system_config_update(gsc_obj)
return
bp_obj = BgpProvisioner(
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
api_server_use_ssl=self._args.api_server_use_ssl,
use_admin_api=self._args.use_admin_api,
sub_cluster_name=self._args.sub_cluster_name,
peer_list=peer_list)
if self._args.oper == 'add':
if self._args.sub_cluster_name:
bp_obj.add_bgp_router('external-control-node',
self._args.host_name, self._args.host_ip,
self._args.router_asn,
self._args.address_families,
self._args.md5,
self._args.local_autonomous_system,
self._args.bgp_server_port)
else:
bp_obj.add_bgp_router(
'control-node', self._args.host_name, self._args.host_ip,
self._args.router_asn, self._args.address_families,
self._args.md5, self._args.local_autonomous_system,
self._args.bgp_server_port)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.host_name)
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def gr_time_type(self, value):
time = int(value)
if time < 0 or time > 4095:
raise argparse.ArgumentTypeError(
"graceful_restart_time %s must be in range (0..4095)" % value)
return time
def llgr_time_type(self, value):
time = int(value)
if time < 0 or time > 16777215:
raise argparse.ArgumentTypeError(
"long_lived_graceful_restart_time %s must be in range (0..16777215)"
% value)
return time
def _parse_args(self, args_str):
'''
Eg. python provision_control.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--router_asn 64512
--ibgp_auto_mesh|--no_ibgp_auto_mesh
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
--md5 <key value>|None(optional)
--bgp_server_port <port>|None(optional)
--local_autonomous_system <ASN value>|None(optional)
--graceful_restart_time 300
--long_lived_graceful_restart_time 300
--end_of_rib_timeout 300
--set_graceful_restart_parameters False
--graceful_restart_bgp_helper_enable False
--graceful_restart_xmpp_helper_enable False
--graceful_restart_enable False
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'router_asn': '64512',
'bgp_server_port': 179,
'local_autonomous_system': None,
'ibgp_auto_mesh': None,
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': None,
'admin_user': None,
'admin_password': None,
'admin_tenant_name': None,
'md5': None,
'graceful_restart_time': 300,
'long_lived_graceful_restart_time': 300,
'end_of_rib_timeout': 300,
'graceful_restart_bgp_helper_enable': False,
'graceful_restart_xmpp_helper_enable': False,
'graceful_restart_enable': False,
'set_graceful_restart_parameters': False,
'sub_cluster_name': None,
'peer_list': None,
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument("--host_name",
help="hostname name of control-node")
parser.add_argument("--host_ip", help="IP address of control-node")
parser.add_argument("--router_asn",
help="AS Number the control-node is in",
required=True)
parser.add_argument("--bgp_server_port",
help="BGP server port number (Default: 179)")
parser.add_argument(
"--local_autonomous_system",
help=
"Local autonomous-system number used to peer contrail-control bgp speakers across different geographic locations"
)
parser.add_argument("--address_families",
help="Address family list",
choices=[
"route-target", "inet-vpn", "e-vpn", "erm-vpn",
"inet6-vpn"
],
nargs="*",
default=[])
parser.add_argument("--md5", help="Md5 config for the node")
parser.add_argument("--ibgp_auto_mesh",
help="Create iBGP mesh automatically",
dest='ibgp_auto_mesh',
action='store_true')
parser.add_argument("--no_ibgp_auto_mesh",
help="Don't create iBGP mesh automatically",
dest='ibgp_auto_mesh',
action='store_false')
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--graceful_restart_time",
help="Graceful Restart Time in seconds (0..4095)",
type=self.gr_time_type,
default=300,
required=False)
parser.add_argument(
"--long_lived_graceful_restart_time",
help="Long Lived Graceful Restart Time in seconds (0..16777215)",
type=self.llgr_time_type,
default=300,
required=False)
parser.add_argument("--end_of_rib_timeout",
help="EndOfRib timeout value in seconds (0..4095)",
type=self.gr_time_type,
default=300,
required=False)
parser.add_argument("--graceful_restart_bgp_helper_enable",
action='store_true',
help="Enable helper mode for BGP graceful restart")
parser.add_argument(
"--graceful_restart_xmpp_helper_enable",
action='store_true',
help="Enable helper mode for XMPP graceful restart")
parser.add_argument("--graceful_restart_enable",
action='store_true',
help="Enable Graceful Restart")
parser.add_argument("--set_graceful_restart_parameters",
action='store_true',
help="Set Graceful Restart Parameters")
parser.add_argument("--sub_cluster_name",
help="sub cluster to associate to",
required=False)
parser.add_argument("--peer_list",
help="list of control node names to peer",
required=False)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class ForwardingModeSetup(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
#import pdb;pdb.set_trace()
vxlan_id = self._args.vxlan_id
vn_name = self._args.vn_name
forwarding_mode = self._args.forwarding_mode
project_fq_name_str = self._args.project_fq_name
project_fq_name = project_fq_name_str.split(':')
#Figure out VN
vni_list = self._vnc_lib.virtual_networks_list(
parent_fq_name=project_fq_name)['virtual-networks']
found = False
for vni_record in vni_list:
if (vni_record['fq_name'][0] == project_fq_name[0]
and vni_record['fq_name'][1] == project_fq_name[1]
and vni_record['fq_name'][2] == vn_name):
vni_obj = self._vnc_lib.virtual_network_read(
id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties(
) or VirtualNetworkType()
if (vxlan_id is not None):
vni_obj_properties.set_vxlan_network_identifier(
int(vxlan_id))
if (forwarding_mode is not None):
vni_obj_properties.set_forwarding_mode(forwarding_mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
self._vnc_lib.virtual_network_update(vni_obj)
found = True
if not found:
print("No Virtual Network %s" % (vn_name))
sys.exit(1)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_forwarding_mode.py
--project_fq_name 'default-domain:admin'
--vn_name vn1
--vxlan_id 100
--forwarding_mode l2
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'route_table_name': 'CustomRouteTable',
'project_fq_name': 'default-domain:admin',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--vn_name", help="VN Name", required=True)
parser.add_argument("--project_fq_name",
help="Fully qualified name of the Project",
required=True)
parser.add_argument("--vxlan_id", help="VxLan ID")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--forwarding_mode",
help="l2_l3 or l2 only",
required=True)
parser.add_argument("--admin_tenant_name",
help="Tenant to create the forwarding mode")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class MxProvisioner(object):
def __init__(self, args_str=None):
self._args = None
self._peer_list = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
self._peer_list = self._args.peer_list.split(',')
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api, self._args.admin_user,
self._args.admin_password, self._args.admin_tenant_name,
self._args.api_server_ip, self._args.api_server_port, '/',
self._args.api_server_use_ssl)
self.add_bgp_router()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.delete_physical_device()
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_mx.py --router_name mx1
--router_ip 10.1.1.1
--loopback_ip 1.1.1.1
--product_name MX80
--device_user root
--device_password pwd
--router_asn 64512
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'router_asn': '64512',
'loopback_ip': None,
'vendor_name': 'Juniper',
'product_name': 'MX80',
'device_user': None,
'device_password': None,
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'role': None,
'admin_user': None,
'admin_password': None,
'admin_tenant_name': None,
'sub_cluster_name': None,
'peer_list': None,
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument("--router_name", help="System name of MX")
parser.add_argument("--router_ip", help="IP address of MX")
parser.add_argument("--router_asn", help="AS Number the MX is in")
parser.add_argument("--loopback_ip", help="Loopback IP address of MX")
parser.add_argument("--product_name",
default='MX80',
help="Product name of the MX",
required=True)
parser.add_argument("--device_user", help="Username for MX login")
parser.add_argument("--device_password", help="Password for MX login")
parser.add_argument("--address_families",
help="Address family list",
choices=[
"route-target", "inet-vpn", "e-vpn", "erm-vpn",
"inet6-vpn"
],
nargs="*",
default=[])
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
default='add',
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--sub_cluster_name",
help="sub cluster to associate to",
required=False)
parser.add_argument("--peer_list",
help="list of control node names to peer",
required=False)
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def _get_rt_inst_obj(self):
vnc_lib = self._vnc_lib
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
return rt_inst_obj
#end _get_rt_inst_obj
def add_bgp_router(self):
bp_obj = BgpProvisioner(self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
self._args.api_server_use_ssl,
self._args.use_admin_api,
peer_list=self._peer_list,
sub_cluster_name=self._args.sub_cluster_name)
if self._args.oper == 'add':
bp_obj.add_bgp_router('router', self._args.router_name,
self._args.router_ip, self._args.router_asn,
self._args.address_families)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.router_name)
else:
print("Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper))
# end add_bgp_router
def add_physical_device(self):
pr = PhysicalRouter(self._args.router_name)
pr.physical_router_management_ip = self._args.router_ip
if self._args.loopback_ip:
pr.physical_router_dataplane_ip = self._args.loopback_ip
pr.physical_router_vendor_name = self._args.vendor_name
pr.physical_router_product_name = self._args.product_name
pr.physical_router_vnc_managed = True
if self._args.role:
pr.physical_router_role = self._args.role
if self._args.device_user and self._args.device_password:
uc = UserCredentials(self._args.device_user,
self._args.device_password)
pr.set_physical_router_user_credentials(uc)
rt_inst_obj = self._get_rt_inst_obj()
fq_name = rt_inst_obj.get_fq_name() + [self._args.router_name]
bgp_router = self._vnc_lib.bgp_router_read(fq_name=fq_name)
pr.set_bgp_router(bgp_router)
self._vnc_lib.physical_router_create(pr)
# end add_physical_device
def del_physical_device(self):
pr_check = GetDevice(self._vnc_lib, self._args.router_name)
uuid = pr_check.Get()
if uuid:
self._vnc_lib.physical_router_delete(id=uuid)
else:
print('No device found with Name : %s' % (self._args.device_name))
class GlobalVrouterConfigProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
if self._args.oper != "add":
conf_obj=GlobalVrouterConfig()
else :
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_global_vrouter_config.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--flow_export_rate 10
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--flow_export_rate", type=int, required=True,
help="Flow export rate to the collector")
parser.add_argument(
"--oper", default='add', choices=['add', 'delete'],
help="Provision operation to be done(add or delete)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class VrouterProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl,
auth_host=self._args.openstack_ip)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
#self.phy_obj = self._vnc_lib.physical_routers_list()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.del_physical_device()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def _parse_args(self, args_str):
'''
Eg: python provision_physical_device.py --device_name my_router
--vendor_name Juniper
--product_name QFX5100
--device_mgmt_ip 10.204.217.39
--device_tunnel_ip 34.34.34.34
--device_tor_agent nodec45-1
--device_tsn nodec45
--api_server_ip 10.204.221.33
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
--admin_user admin
--admin_password contrail123
--admin_tenant_name admin
--openstack_ip 10.204.221.34
--snmp_monitor
--local_port 161
--v2_community public
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--device_name", help="Name of physical device", required=True)
parser.add_argument(
"--vendor_name", help="Vendor type of the device", required=True)
parser.add_argument(
"--product_name", default='', help="Product name of the device")
parser.add_argument(
"--device_mgmt_ip", help="Management IP of the device")
parser.add_argument(
"--device_tunnel_ip", help="Tunnel IP of the device")
parser.add_argument(
"--device_tor_agent", help="Tor Agent Name for the device")
parser.add_argument(
"--device_tsn", help="TSN Name for the device")
parser.add_argument(
"--snmp_monitor", help="monitor through snmp", action='store_true')
parser.add_argument(
"--local_port", help="snmp port to connect to")
parser.add_argument(
"--v2_community", help="community string for snmp")
parser.add_argument(
"--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--openstack_ip", help="Openstack node ip")
parser.add_argument(
"--oper", default='add', help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_physical_device(self):
pr = PhysicalRouter(self._args.device_name)
pr.physical_router_dataplane_ip = self._args.device_tunnel_ip
pr.physical_router_management_ip = self._args.device_mgmt_ip
pr.physical_router_vendor_name = self._args.vendor_name
pr.physical_router_product_name = self._args.product_name
pr_check=GetDevice(self._vnc_lib, self._args.device_name)
if pr_check.Get():
pr_id = self._vnc_lib.physical_router_update(pr)
else:
pr_id = self._vnc_lib.physical_router_create(pr)
# Associate TSN and Tor agent with Physical Device
for member in [self._args.device_tsn, self._args.device_tor_agent]:
vrouter_tmp = GetVrouter(self._vnc_lib, member)
vrouter = vrouter_tmp.Get()
if vrouter:
pr.add_virtual_router(vrouter)
if self._args.snmp_monitor:
local_port = 161
if self._args.local_port:
local_port = self._args.local_port
v2_community = 'public'
if self._args.v2_community:
v2_community = self._args.v2_community
snmp_credentials = SNMPCredentials(local_port=local_port, v2_community=v2_community)
pr.set_physical_router_snmp_credentials(snmp_credentials)
self._vnc_lib.physical_router_update(pr)
# end add_physical_device
def del_physical_device(self):
pr_check=GetDevice(self._vnc_lib, self._args.device_name)
uuid=pr_check.Get()
if uuid:
self._vnc_lib.physical_router_delete(id=uuid)
else:
print 'No device found with Name : %s' %(self._args.device_name)
class MxProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
peer_list = self._args.peer_list.split(',')
else:
peer_list = None
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api, self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name, self._args.api_server_ip,
self._args.api_server_port, '/', self._args.api_server_use_ssl)
self.add_bgp_router()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.delete_physical_device()
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_mx.py --router_name mx1
--router_ip 10.1.1.1
--loopback_ip 1.1.1.1
--product_name MX80
--device_user root
--device_password pwd
--router_asn 64512
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'router_asn': '64512',
'loopback_ip': None,
'vendor_name': 'Juniper',
'product_name': 'MX80',
'device_user': None,
'device_password': None,
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'role': None,
'admin_user': None,
'admin_password': None,
'admin_tenant_name': None,
'sub_cluster_name': None,
'peer_list': None,
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument("--router_name", help="System name of MX")
parser.add_argument("--router_ip", help="IP address of MX")
parser.add_argument("--router_asn", help="AS Number the MX is in")
parser.add_argument("--loopback_ip", help="Loopback IP address of MX")
parser.add_argument(
"--product_name", default='MX80', help="Product name of the MX", required=True)
parser.add_argument(
"--device_user", help="Username for MX login")
parser.add_argument(
"--device_password", help="Password for MX login")
parser.add_argument(
"--address_families", help="Address family list",
choices=["route-target", "inet-vpn", "e-vpn", "erm-vpn", "inet6-vpn"],
nargs="*", default=[])
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--oper", default='add',
help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenamt name for keystone admin user")
parser.add_argument(
"--sub_cluster_name", help="sub cluster to associate to",
required=False)
parser.add_argument(
"--peer_list", help="list of control node names to peer",
required=False)
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server",
nargs='+', type=str)
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def _get_rt_inst_obj(self):
vnc_lib = self._vnc_lib
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(
fq_name=['default-domain', 'default-project',
'ip-fabric', '__default__'])
return rt_inst_obj
#end _get_rt_inst_obj
def add_bgp_router(self):
bp_obj = BgpProvisioner(
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name, self._args.api_server_ip,
self._args.api_server_port, self._args.api_server_use_ssl,
self._args.use_admin_api, peer_list=peer_list,
sub_cluster_name=self._args.sub_cluster_name)
if self._args.oper == 'add':
bp_obj.add_bgp_router('router', self._args.router_name,
self._args.router_ip, self._args.router_asn,
self._args.address_families)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.router_name)
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end add_bgp_router
def add_physical_device(self):
pr = PhysicalRouter(self._args.router_name)
pr.physical_router_management_ip = self._args.router_ip
if self._args.loopback_ip:
pr.physical_router_dataplane_ip = self._args.loopback_ip
pr.physical_router_vendor_name = self._args.vendor_name
pr.physical_router_product_name = self._args.product_name
pr.physical_router_vnc_managed = True
if self._args.role:
pr.physical_router_role = self._args.role
if self._args.device_user and self._args.device_password:
uc = UserCredentials(self._args.device_user, self._args.device_password)
pr.set_physical_router_user_credentials(uc)
rt_inst_obj = self._get_rt_inst_obj()
fq_name = rt_inst_obj.get_fq_name() + [self._args.router_name]
bgp_router = self._vnc_lib.bgp_router_read(fq_name=fq_name)
pr.set_bgp_router(bgp_router)
self._vnc_lib.physical_router_create(pr)
# end add_physical_device
def del_physical_device(self):
pr_check=GetDevice(self._vnc_lib, self._args.router_name)
uuid=pr_check.Get()
if uuid:
self._vnc_lib.physical_router_delete(id=uuid)
else:
print 'No device found with Name : %s' %(self._args.device_name)
class BgpProvisioner(object):
def __init__(self, user, password, tenant, api_server_ip, api_server_port,
api_server_use_ssl=False, use_admin_api=False,
sub_cluster_name=None, peer_list=None):
self._admin_user = user
self._admin_password = password
self._admin_tenant_name = tenant
self._api_server_ip = api_server_ip
self._api_server_port = api_server_port
self._api_server_use_ssl = api_server_use_ssl
self._sub_cluster_name = sub_cluster_name
self._peer_list = peer_list
self._vnc_lib = VncApiAdmin(
use_admin_api, self._admin_user, self._admin_password,
self._admin_tenant_name,
self._api_server_ip,
self._api_server_port, '/',
api_server_use_ssl=self._api_server_use_ssl)
# end __init__
def _get_rt_inst_obj(self):
vnc_lib = self._vnc_lib
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(
fq_name=['default-domain', 'default-project',
'ip-fabric', '__default__'])
return rt_inst_obj
# end _get_rt_inst_obj
def add_bgp_router(self, router_type, router_name, router_ip,
router_asn, address_families=[], md5=None,
local_asn=None, port=179):
if not address_families:
address_families = ['route-target', 'inet-vpn', 'e-vpn', 'erm-vpn',
'inet6-vpn']
if router_type != 'control-node':
address_families.remove('erm-vpn')
if router_type != 'control-node':
if 'erm-vpn' in address_families:
raise RuntimeError("Only contrail bgp routers can support "
"family 'erm-vpn'")
bgp_addr_fams = AddressFamilies(address_families)
bgp_sess_attrs = [
BgpSessionAttributes(address_families=bgp_addr_fams)]
bgp_sessions = [BgpSession(attributes=bgp_sess_attrs)]
bgp_peering_attrs = BgpPeeringAttributes(session=bgp_sessions)
rt_inst_obj = self._get_rt_inst_obj()
vnc_lib = self._vnc_lib
if router_type == 'control-node':
vendor = 'contrail'
elif router_type == 'router':
vendor = 'mx'
else:
vendor = 'unknown'
router_params = BgpRouterParams(router_type=router_type,
vendor=vendor, autonomous_system=int(router_asn),
identifier=get_ip(router_ip),
address=get_ip(router_ip),
port=port, address_families=bgp_addr_fams)
if md5:
md5 = {'key_items': [ { 'key': md5 ,"key_id":0 } ], "key_type":"md5"}
router_params.set_auth_data(md5)
if local_asn:
local_asn = int(local_asn)
if local_asn <= 0 or local_asn > 65535:
raise argparse.ArgumentTypeError("local_asn %s must be in range (1..65535)" % local_asn)
router_params.set_local_autonomous_system(local_asn)
bgp_router_obj = BgpRouter(router_name, rt_inst_obj,
bgp_router_parameters=router_params)
bgp_router_fq_name = bgp_router_obj.get_fq_name()
peer_list = self._peer_list
fqname_peer_list = None
fqname_peer_set = None
if peer_list is not None:
fqname_peer_list = []
fqname_peer_set = set()
for peer in peer_list:
peer_router_obj = BgpRouter(peer, rt_inst_obj)
try:
vnc_lib.bgp_router_create(peer_router_obj)
except RefsExistError as e:
pass
finally:
fqname_peer_list.append(peer_router_obj.get_fq_name())
fqname_peer_set.add(tuple(peer_router_obj.get_fq_name()))
try:
# full-mesh with existing bgp routers
if self._sub_cluster_name:
sub_cluster_obj = SubCluster(self._sub_cluster_name)
try:
sub_cluster_obj = self._vnc_lib.sub_cluster_read(
fq_name=sub_cluster_obj.get_fq_name())
except NoIdError:
raise RuntimeError("Sub cluster to be provisioned first")
bgp_router_obj.add_sub_cluster(sub_cluster_obj)
if fqname_peer_list:
bgp_router_obj.set_bgp_router_list(fqname_peer_list,
[bgp_peering_attrs]*len(fqname_peer_list))
vnc_lib.bgp_router_create(bgp_router_obj)
except RefsExistError as e:
print ("BGP Router " + pformat(bgp_router_fq_name) +
" already exists " + str(e))
cur_obj = vnc_lib.bgp_router_read(
fq_name=bgp_router_fq_name,
fields=['global_system_config_back_refs'])
changed = False
if cur_obj.bgp_router_parameters != router_params:
cur_obj.set_bgp_router_parameters(router_params)
changed = True
cur_bgp_router_set = {tuple(x['to'])
for x in cur_obj.get_bgp_router_refs() or []}
if peer_list is not None and fqname_peer_set != cur_bgp_router_set:
cur_obj.set_bgp_router_list(fqname_peer_list,
[bgp_peering_attrs]*len(fqname_peer_list))
changed = True
if self._sub_cluster_name and not cur_obj.get_sub_cluster_refs():
cur_obj.add_sub_cluster(sub_cluster_obj)
changed = True
if changed:
vnc_lib.bgp_router_update(cur_obj)
bgp_router_obj = cur_obj
if (router_type == 'control-node' and
not bgp_router_obj.get_global_system_config_back_refs()):
gsc_obj = vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.add_bgp_router(bgp_router_obj)
vnc_lib.ref_relax_for_delete(gsc_obj.uuid, bgp_router_obj.uuid)
vnc_lib.global_system_config_update(gsc_obj)
# end add_bgp_router
def del_bgp_router(self, router_name):
rt_inst_obj = self._get_rt_inst_obj()
fq_name = rt_inst_obj.get_fq_name() + [router_name]
self._vnc_lib.bgp_router_delete(fq_name=fq_name)
# end del_bgp_router
def add_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
route_targets = net_obj.get_route_target_list()
if route_targets:
route_targets.add_route_target(rtgt_val)
else:
route_targets = RouteTargetList([rtgt_val])
net_obj.set_route_target_list(route_targets)
vnc_lib.virtual_network_update(net_obj)
# end add_route_target
def del_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
if rtgt_val not in net_obj.get_route_target_list().get_route_target():
print "%s not configured for VN %s" % (rtgt_val,
rt_inst_fq_name[:-1])
return
route_targets = net_obj.get_route_target_list()
route_targets.delete_route_target(rtgt_val)
if route_targets.get_route_target():
net_obj.set_route_target_list(route_targets)
else:
net_obj.set_route_target_list(None)
vnc_lib.virtual_network_update(net_obj)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
port_trans_pool_list = []
if self._args.snat_list:
port=None
protocol=None
for proto_port in self._args.snat_list:
port_count=''
port_range_obj=None
protocol = proto_port.split(':')[0]
port = proto_port.split(':')[1]
if '-' in port:
port_range_obj = PortType(start_port=int(port.split('-')[0]),
end_port=int(port.split('-')[1]))
else:
port_count = port
port_trans_pool_obj = PortTranslationPool(protocol = protocol,
port_range = port_range_obj,
port_count = port_count)
port_trans_pool_list.append(port_trans_pool_obj)
port_trans_pools_obj = PortTranslationPools(port_trans_pool_list)
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(port_trans_pools_obj)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
existing_snat_pools = current_config.get_port_translation_pools()
if not existing_snat_pools:
existing_snat_pools = PortTranslationPools([])
if port_trans_pool_list:
for snat_pool in port_trans_pool_list:
if not self.check_dup_snat_pool(snat_pool, existing_snat_pools):
existing_snat_pools.add_port_translation_pool(snat_pool)
if self._args.oper != "add":
conf_obj=GlobalVrouterConfig()
else:
conf_obj=GlobalVrouterConfig(flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(existing_snat_pools)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
linklocal_obj=LinklocalServiceEntryType(
linklocal_service_name=self._args.linklocal_service_name,
linklocal_service_ip=self._args.linklocal_service_ip,
linklocal_service_port=self._args.linklocal_service_port,
ip_fabric_DNS_service_name=self._args.ipfabric_dns_service_name,
ip_fabric_service_port=self._args.ipfabric_service_port)
if self._args.ipfabric_service_ip:
linklocal_obj.ip_fabric_service_ip=[self._args.ipfabric_service_ip]
try:
current_config=self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
except Exception as e:
try:
if self._args.oper == "add":
linklocal_services_obj=LinklocalServicesTypes([linklocal_obj])
conf_obj=GlobalVrouterConfig(linklocal_services=linklocal_services_obj)
result=self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created!"
current_linklocal=current_config.get_linklocal_services()
if current_linklocal is None:
obj = {'linklocal_service_entry': []}
else:
obj = current_linklocal.__dict__
new_linklocal=[]
for key, value in obj.iteritems():
found=False
for vl in value:
entry = vl.__dict__
if ('linklocal_service_name' in entry and
entry['linklocal_service_name'] == self._args.linklocal_service_name):
if self._args.oper == "add":
new_linklocal.append(linklocal_obj)
found=True
else:
new_linklocal.append(vl)
if not found and self._args.oper == "add":
new_linklocal.append(linklocal_obj)
obj[key] = new_linklocal
conf_obj=GlobalVrouterConfig(linklocal_services=obj)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
class ForwardingModeSetup(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
#import pdb;pdb.set_trace()
vxlan_id = self._args.vxlan_id
vn_name = self._args.vn_name
forwarding_mode = self._args.forwarding_mode
project_fq_name_str = self._args.project_fq_name
project_fq_name = project_fq_name_str.split(':')
#Figure out VN
vni_list = self._vnc_lib.virtual_networks_list(
parent_fq_name = project_fq_name)['virtual-networks']
found = False
for vni_record in vni_list:
if (vni_record['fq_name'][0] == project_fq_name[0] and
vni_record['fq_name'][1] == project_fq_name[1] and
vni_record['fq_name'][2] == vn_name):
vni_obj = self._vnc_lib.virtual_network_read(
id = vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties() or VirtualNetworkType()
if (vxlan_id is not None):
vni_obj_properties.set_vxlan_network_identifier(int(vxlan_id))
if (forwarding_mode is not None):
vni_obj_properties.set_forwarding_mode(forwarding_mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
self._vnc_lib.virtual_network_update(vni_obj)
found = True
if not found:
print "No Virtual Network %s" %(vn_name)
sys.exit(1)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_forwarding_mode.py
--project_fq_name 'default-domain:admin'
--vn_name vn1
--vxlan_id 100
--forwarding_mode l2
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'route_table_name': 'CustomRouteTable',
'project_fq_name' : 'default-domain:admin',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--vn_name", help="VN Name", required=True)
parser.add_argument(
"--project_fq_name", help="Fully qualified name of the Project", required=True)
parser.add_argument(
"--vxlan_id", help="VxLan ID")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument(
"--forwarding_mode", help="l2_l3 or l2 only", required=True)
parser.add_argument(
"--admin_tenant_name", help="Tenant to create the forwarding mode")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class VrouterProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl,
auth_host=self._args.openstack_ip)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
#self.phy_obj = self._vnc_lib.physical_routers_list()
if self._args.oper == 'add':
self.add_physical_device()
elif self._args.oper == 'del':
self.del_physical_device()
else:
print("Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper))
# end __init__
def _parse_args(self, args_str):
'''
Eg: python provision_physical_device.py --device_name my_router
--vendor_name Juniper
--product_name QFX5100
--device_mgmt_ip 10.204.217.39
--device_tunnel_ip 34.34.34.34
--device_tor_agent nodec45-1
--device_tsn nodec45
--api_server_ip 10.204.221.33
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
--admin_user admin
--admin_password contrail123
--admin_tenant_name admin
--openstack_ip 10.204.221.34
--snmp_monitor
--local_port 161
--v2_community public
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--device_name", help="Name of physical device", required=True)
parser.add_argument(
"--vendor_name", help="Vendor type of the device", required=True)
parser.add_argument(
"--product_name", default='', help="Product name of the device")
parser.add_argument(
"--device_mgmt_ip", help="Management IP of the device")
parser.add_argument(
"--device_tunnel_ip", help="Tunnel IP of the device")
parser.add_argument(
"--device_tor_agent", help="Tor Agent Name for the device")
parser.add_argument(
"--device_tsn", help="TSN Name for the device")
parser.add_argument(
"--snmp_monitor", help="monitor through snmp", action='store_true')
parser.add_argument(
"--local_port", help="snmp port to connect to")
parser.add_argument(
"--v2_community", help="community string for snmp")
parser.add_argument(
"--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--openstack_ip", help="Openstack node ip")
parser.add_argument(
"--oper", default='add', help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_physical_device(self):
pr = PhysicalRouter(self._args.device_name)
pr.physical_router_dataplane_ip = self._args.device_tunnel_ip
pr.physical_router_management_ip = self._args.device_mgmt_ip
pr.physical_router_vendor_name = self._args.vendor_name
pr.physical_router_product_name = self._args.product_name
pr_check=GetDevice(self._vnc_lib, self._args.device_name)
if pr_check.Get():
pr_id = self._vnc_lib.physical_router_update(pr)
else:
pr_id = self._vnc_lib.physical_router_create(pr)
# Associate TSN and Tor agent with Physical Device
for member in [self._args.device_tsn, self._args.device_tor_agent]:
vrouter_tmp = GetVrouter(self._vnc_lib, member)
vrouter = vrouter_tmp.Get()
if vrouter:
pr.add_virtual_router(vrouter)
if self._args.snmp_monitor:
local_port = 161
if self._args.local_port:
local_port = self._args.local_port
v2_community = 'public'
if self._args.v2_community:
v2_community = self._args.v2_community
snmp_credentials = SNMPCredentials(local_port=local_port, v2_community=v2_community)
pr.set_physical_router_snmp_credentials(snmp_credentials)
self._vnc_lib.physical_router_update(pr)
# end add_physical_device
def del_physical_device(self):
pr_check=GetDevice(self._vnc_lib, self._args.device_name)
uuid=pr_check.Get()
if uuid:
self._vnc_lib.physical_router_delete(id=uuid)
else:
print('No device found with Name : %s' %(self._args.device_name))
class EncapsulationProvision(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
global_vrouter_fq_name = ['default-global-system-config',
'default-global-vrouter-config']
if self._args.oper == "add":
encap_obj = EncapsulationPrioritiesType(
encapsulation=self._args.encap_priority.split(","))
conf_obj = GlobalVrouterConfig(encapsulation_priorities=encap_obj,
vxlan_network_identifier_mode=self._args.vxlan_vn_id_mode,
fq_name=global_vrouter_fq_name)
try:
result = self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s' % result
except RefsExistError:
print "Already created! Updating the object."
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s' % result
return
elif self._args.oper != "add":
encap_obj = EncapsulationPrioritiesType(encapsulation=[])
conf_obj = GlobalVrouterConfig(encapsulation_priorities=encap_obj,
fq_name=global_vrouter_fq_name)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_encap.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--encap_priority "MPLSoUDP,MPLSoGRE,VXLAN"
--vxlan_vn_id_mode "automatic"
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'encap_priority': 'MPLSoUDP,MPLSoGRE,VXLAN',
'vxlan_vn_id_mode' : 'automatic'
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--encap_priority", help="List of Encapsulation priority", required=True)
parser.add_argument(
"--vxlan_vn_id_mode", help="Virtual Network id type to be used")
parser.add_argument(
"--oper", default='add',help="Provision operation to be done(add or delete)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
if not self._args.encap_priority:
parser.error('encap_priority is required')
class StaticRouteProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.user,
self._args.password,
self._args.tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
prefix = self._args.prefix
vmi_id_got = self._args.virtual_machine_interface_id
route_table_name = self._args.route_table_name
try:
ip_nw = IPNetwork(prefix)
except AddrFormatError:
print('Invalid ip address format')
sys.exit(1)
project_fq_name_str = 'default-domain:' + self._args.tenant_name
project_fq_name = project_fq_name_str.split(':')
project_obj = self._vnc_lib.project_read(fq_name=project_fq_name)
route_table = RouteTableType(route_table_name)
route_table.set_route([])
intf_route_table = InterfaceRouteTable(
interface_route_table_routes=route_table,
parent_obj=project_obj,
name=route_table_name)
try:
route_table_obj = self._vnc_lib.interface_route_table_read(
fq_name=intf_route_table.get_fq_name())
intf_route_table_id = route_table_obj.uuid
except NoIdError:
if self._args.oper == 'del':
print("Route table %s does not exist" % (route_table_name))
sys.exit(1)
print("Creating Route table")
intf_route_table_id = self._vnc_lib.interface_route_table_create(
intf_route_table)
intf_route_table_obj = self._vnc_lib.interface_route_table_read(
id=intf_route_table_id)
if self._args.oper == 'add':
intf_route_table_obj = self.add_route(intf_route_table_obj, prefix)
elif self._args.oper == 'del':
intf_route_table_obj = self.del_route(intf_route_table_obj, prefix)
self._vnc_lib.interface_route_table_update(intf_route_table_obj)
#Update the VMI Object now
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id=vmi_id_got)
if self._args.oper == 'add':
vmi_obj.add_interface_route_table(intf_route_table_obj)
elif self._args.oper == 'del':
if self.is_route_table_empty(intf_route_table_obj):
vmi_obj.del_interface_route_table(intf_route_table_obj)
self._vnc_lib.virtual_machine_interface_update(vmi_obj)
# end __init__
def add_route(self, intf_route_table_obj, prefix):
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
routes = rt_routes.get_route()
found = False
for route in routes:
if route.prefix == prefix:
print(
"Prefix already present in Interface Route Table, not adding"
)
found = True
sys.exit(0)
if not found:
rt1 = RouteType(prefix=prefix)
routes.append(rt1)
intf_route_table_obj.set_interface_route_table_routes(rt_routes)
return intf_route_table_obj
#end add_route
def del_route(self, intf_route_table_obj, prefix):
# routes = intf_route_table_obj['interface_route_table_routes']['route']
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
routes = rt_routes.get_route()
found = False
for route in routes:
if route.prefix == prefix:
found = True
routes.remove(route)
if not found:
print("Prefix %s not found in Route table %s!" %
(prefix, intf_route_table_obj.name))
sys.exit(1)
intf_route_table_obj.set_interface_route_table_routes(rt_routes)
return intf_route_table_obj
def is_route_table_empty(self, intf_route_table_obj):
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
if len(rt_routes.get_route()) == 0:
return True
else:
return False
#end is_route_table_empty
def _parse_args(self, args_str):
'''
Eg. python provision_static_route.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--prefix 2.2.2.0/24
--virtual_machine_interface_id 242717c9-8e78-4c67-94a8-5fbef1f2f096
--route_table_name "MyRouteTable"
--tenant_name "admin"
--oper <add | del>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'route_table_name': 'CustomRouteTable',
}
ksopts = {
'user': '******',
'password': '******',
'tenant_name': 'default-domain'
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--prefix",
help="IP Destination prefix to be updated in the Route",
required=True)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
default='add',
help="Provision operation to be done(add or del)")
parser.add_argument(
"--virtual_machine_interface_id",
help="Next hop which is the UUID of the VMI(aka port-id)")
parser.add_argument("--tenant_name",
help="Tenant name for keystone admin user")
parser.add_argument("--user", help="Name of keystone admin user")
parser.add_argument("--password",
help="Password of keystone admin user")
parser.add_argument(
"--route_table_name",
help="Route Table name. Default : CustomRouteTable")
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class MetadataProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
linklocal_obj=LinklocalServiceEntryType(
linklocal_service_name=self._args.linklocal_service_name,
linklocal_service_ip=self._args.linklocal_service_ip,
linklocal_service_port=self._args.linklocal_service_port,
ip_fabric_DNS_service_name=self._args.ipfabric_dns_service_name,
ip_fabric_service_port=self._args.ipfabric_service_port)
if self._args.ipfabric_service_ip:
linklocal_obj.ip_fabric_service_ip=[self._args.ipfabric_service_ip]
try:
if self._args.oper == "add":
linklocal_services_obj = LinklocalServicesTypes([linklocal_obj])
conf_obj = GlobalVrouterConfig(linklocal_services=linklocal_services_obj)
result = self._vnc_lib.global_vrouter_config_create(conf_obj)
print 'Created.UUID is %s'%(result)
return
except RefsExistError:
print "Already created! Updating the object."
sleep(5)
current_config = self._vnc_lib.global_vrouter_config_read(
fq_name=['default-global-system-config', 'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
if current_linklocal is None:
obj = {'linklocal_service_entry': []}
else:
obj = current_linklocal.__dict__
new_linklocal=[]
for key, value in obj.iteritems():
found=False
for vl in value:
entry = vl.__dict__
if ('linklocal_service_name' in entry and
entry['linklocal_service_name'] == self._args.linklocal_service_name):
if self._args.oper == "add":
new_linklocal.append(linklocal_obj)
found=True
else:
new_linklocal.append(vl)
if not found and self._args.oper == "add":
new_linklocal.append(linklocal_obj)
obj[key] = new_linklocal
conf_obj=GlobalVrouterConfig(linklocal_services=obj)
result=self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s'%(result)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_metadata.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--linklocal_service_name name
--linklocal_service_ip 1.2.3.4
--linklocal_service_port 1234
--ipfabric_dns_service_name fabric_server_name
--ipfabric_service_ip 10.1.1.1
--ipfabric_service_port 5775
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'linklocal_service_name': '',
'linklocal_service_ip': '',
'linklocal_service_port': 0,
'ipfabric_dns_service_name': '',
'ipfabric_service_ip': [],
'ipfabric_service_port': 0,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--linklocal_service_name", help="Service Name")
parser.add_argument(
"--linklocal_service_ip", help="Link Local Service IP")
parser.add_argument(
"--linklocal_service_port", type=int, help="Link Local Service Port")
parser.add_argument(
"--ipfabric_dns_service_name", help="IP Fabric DNS Service Name")
parser.add_argument(
"--ipfabric_service_ip", help="IP Fabric Service IP")
parser.add_argument(
"--ipfabric_service_port", type=int, help="IP Fabric Service Port")
parser.add_argument(
"--oper", default='add', help="Provision operation to be done(add or delete)")
parser.add_argument(
"--admin_tenant_name", help="Tenant to create the Link Local Service")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
if not self._args.linklocal_service_name:
parser.error('linklocal_service_name is required')
class BgpProvisioner(object):
def __init__(self,
user,
password,
tenant,
api_server_ip,
api_server_port,
api_server_use_ssl=False,
use_admin_api=False):
self._admin_user = user
self._admin_password = password
self._admin_tenant_name = tenant
self._api_server_ip = api_server_ip
self._api_server_port = api_server_port
self._api_server_use_ssl = api_server_use_ssl
self._vnc_lib = VncApiAdmin(
use_admin_api,
self._admin_user,
self._admin_password,
self._admin_tenant_name,
self._api_server_ip,
self._api_server_port,
'/',
api_server_use_ssl=self._api_server_use_ssl)
# end __init__
def _get_rt_inst_obj(self):
vnc_lib = self._vnc_lib
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
return rt_inst_obj
# end _get_rt_inst_obj
def add_bgp_router(self,
router_type,
router_name,
router_ip,
router_asn,
address_families=[],
md5=None,
local_asn=None,
port=179):
if not address_families:
address_families = [
'route-target', 'inet-vpn', 'e-vpn', 'erm-vpn', 'inet6-vpn'
]
if router_type != 'control-node':
address_families.remove('erm-vpn')
if router_type != 'control-node':
if 'erm-vpn' in address_families:
raise RuntimeError("Only contrail bgp routers can support "
"family 'erm-vpn'")
bgp_addr_fams = AddressFamilies(address_families)
bgp_sess_attrs = [BgpSessionAttributes(address_families=bgp_addr_fams)]
bgp_sessions = [BgpSession(attributes=bgp_sess_attrs)]
bgp_peering_attrs = BgpPeeringAttributes(session=bgp_sessions)
rt_inst_obj = self._get_rt_inst_obj()
vnc_lib = self._vnc_lib
if router_type == 'control-node':
vendor = 'contrail'
elif router_type == 'router':
vendor = 'mx'
else:
vendor = 'unknown'
router_params = BgpRouterParams(router_type=router_type,
vendor=vendor,
autonomous_system=int(router_asn),
identifier=get_ip(router_ip),
address=get_ip(router_ip),
port=port,
address_families=bgp_addr_fams)
bgp_router_obj = BgpRouter(router_name,
rt_inst_obj,
bgp_router_parameters=router_params)
bgp_router_fq_name = bgp_router_obj.get_fq_name()
try:
# full-mesh with existing bgp routers
fq_name = rt_inst_obj.get_fq_name()
bgp_router_list = vnc_lib.bgp_routers_list(parent_fq_name=fq_name)
bgp_router_names = [
bgp_dict['fq_name']
for bgp_dict in bgp_router_list['bgp-routers']
]
bgp_router_obj.set_bgp_router_list(
bgp_router_names, [bgp_peering_attrs] * len(bgp_router_names))
vnc_lib.bgp_router_create(bgp_router_obj)
except RefsExistError as e:
print("BGP Router " + pformat(bgp_router_fq_name) +
" already exists " + str(e))
if md5:
cur_obj = vnc_lib.bgp_router_read(fq_name=bgp_router_fq_name)
md5 = {'key_items': [{'key': md5, "key_id": 0}], "key_type": "md5"}
rparams = cur_obj.bgp_router_parameters
rparams.set_auth_data(md5)
cur_obj.set_bgp_router_parameters(rparams)
vnc_lib.bgp_router_update(cur_obj)
if local_asn:
cur_obj = vnc_lib.bgp_router_read(fq_name=bgp_router_fq_name)
local_asn = int(local_asn)
if local_asn <= 0 or local_asn > 65535:
raise argparse.ArgumentTypeError(
"local_asn %s must be in range (1..65535)" % local_asn)
rparams = cur_obj.bgp_router_parameters
rparams.set_local_autonomous_system(local_asn)
cur_obj.set_bgp_router_parameters(rparams)
vnc_lib.bgp_router_update(cur_obj)
# end add_bgp_router
def del_bgp_router(self, router_name):
rt_inst_obj = self._get_rt_inst_obj()
fq_name = rt_inst_obj.get_fq_name() + [router_name]
self._vnc_lib.bgp_router_delete(fq_name=fq_name)
# end del_bgp_router
def add_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
route_targets = net_obj.get_route_target_list()
if route_targets:
route_targets.add_route_target(rtgt_val)
else:
route_targets = RouteTargetList([rtgt_val])
net_obj.set_route_target_list(route_targets)
vnc_lib.virtual_network_update(net_obj)
# end add_route_target
def del_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
if rtgt_val not in net_obj.get_route_target_list().get_route_target():
print "%s not configured for VN %s" % (rtgt_val,
rt_inst_fq_name[:-1])
return
route_targets = net_obj.get_route_target_list()
route_targets.delete_route_target(rtgt_val)
if route_targets.get_route_target():
net_obj.set_route_target_list(route_targets)
else:
net_obj.set_route_target_list(None)
vnc_lib.virtual_network_update(net_obj)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
port_trans_pool_list = []
if self._args.snat_list:
port = None
protocol = None
for proto_port in self._args.snat_list:
port_count = ''
port_range_obj = None
protocol = proto_port.split(':')[0]
port = proto_port.split(':')[1]
if '-' in port:
port_range_obj = PortType(start_port=int(
port.split('-')[0]),
end_port=int(port.split('-')[1]))
else:
port_count = port
port_trans_pool_obj = PortTranslationPool(
protocol=protocol,
port_range=port_range_obj,
port_count=port_count)
port_trans_pool_list.append(port_trans_pool_obj)
port_trans_pools_obj = PortTranslationPools(port_trans_pool_list)
try:
current_config = self._vnc_lib.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(port_trans_pools_obj)
result = self._vnc_lib.global_vrouter_config_create(
conf_obj)
print('Created.UUID is %s' % (result))
return
except RefsExistError:
print("Already created!")
existing_snat_pools = current_config.get_port_translation_pools()
if not existing_snat_pools:
existing_snat_pools = PortTranslationPools([])
if port_trans_pool_list:
for snat_pool in port_trans_pool_list:
if not self.check_dup_snat_pool(snat_pool,
existing_snat_pools):
existing_snat_pools.add_port_translation_pool(snat_pool)
if self._args.oper != "add":
conf_obj = GlobalVrouterConfig()
else:
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(existing_snat_pools)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print('Updated.%s' % (result))
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
peer_list = self._args.peer_list.split(',')
else:
peer_list = None
if self._args.router_asn and not self._args.oper:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
# Update global system config also with this ASN
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.set_autonomous_system(self._args.router_asn)
if self._args.ibgp_auto_mesh is not None:
gsc_obj.set_ibgp_auto_mesh(self._args.ibgp_auto_mesh)
if self._args.set_graceful_restart_parameters == True:
gr_params = GracefulRestartParametersType()
gr_params.set_restart_time(
int(self._args.graceful_restart_time))
gr_params.set_long_lived_restart_time(
int(self._args.long_lived_graceful_restart_time))
gr_params.set_end_of_rib_timeout(
int(self._args.end_of_rib_timeout))
gr_params.set_enable(self._args.graceful_restart_enable)
gr_params.set_bgp_helper_enable(
self._args.graceful_restart_bgp_helper_enable)
gr_params.set_xmpp_helper_enable(
self._args.graceful_restart_xmpp_helper_enable)
gsc_obj.set_graceful_restart_parameters(gr_params)
self._vnc_lib.global_system_config_update(gsc_obj)
return
bp_obj = BgpProvisioner(
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
api_server_use_ssl=self._args.api_server_use_ssl,
use_admin_api=self._args.use_admin_api,
sub_cluster_name=self._args.sub_cluster_name,
peer_list=peer_list)
if self._args.oper == 'add':
if self._args.sub_cluster_name:
bp_obj.add_bgp_router('external-control-node',
self._args.host_name, self._args.host_ip,
self._args.router_asn,
self._args.address_families,
self._args.md5,
self._args.local_autonomous_system,
self._args.bgp_server_port)
else:
bp_obj.add_bgp_router(
'control-node', self._args.host_name, self._args.host_ip,
self._args.router_asn, self._args.address_families,
self._args.md5, self._args.local_autonomous_system,
self._args.bgp_server_port)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.host_name)
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
class VrouterProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
rt_inst_obj = self._vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
self._fab_rt_inst_obj = rt_inst_obj
if self._args.oper == 'add':
self.add_vrouter()
if not self._args.disable_vhost_vmi:
self.add_vhost0_vmi()
elif self._args.oper == 'del':
self.del_vhost0_vmi()
self.del_vrouter()
else:
print("Unknown operation %s. Only 'add' and 'del' supported" %
(self._args.oper))
# end __init__
def _parse_args(self, args_str):
"""
Sample usage.
python provision_vrouter.py
--host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
[--ip_fabric_subnet 192.168.10.0/24]
[--dpdk-enabled]
[--sriov-physnets physnet1=eth0 physnet2=eth1]
"""
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'router_type': None,
'dpdk_enabled': False,
'disable_vhost_vmi': False,
'enable_vhost_vmi_policy': False,
'sub_cluster_name': None,
'ip_fabric_subnet': None
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--host_name",
help="hostname name of compute-node",
required=True)
parser.add_argument("--host_ip",
help="IP address of compute-node",
required=True)
parser.add_argument(
"--control_names",
help="List of control-node names compute node connects to")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
default='add',
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--openstack_ip",
help="IP address of openstack node")
parser.add_argument(
"--router_type",
help="Type of the virtual router (tor-service-node,embedded,none)")
parser.add_argument(
"--dpdk_enabled",
action="store_true",
help="Whether forwarding mode on vrouter is DPDK based")
parser.add_argument("--disable_vhost_vmi",
action="store_true",
help="Do not create vhost0 vmi if flag is set")
parser.add_argument("--enable_vhost_vmi_policy",
action="store_true",
help="Enable vhost0 vmi policy if flag is set")
parser.add_argument("--sub_cluster_name",
help="Sub cluster this vrouter to be part of")
parser.add_argument("--ip_fabric_subnet",
help="Add the ip_fabric_subnet")
parser.add_argument("--sriov_physnets",
metavar="KEY=VALUE",
nargs='+',
action=SriovPhysNetAction,
help="physnet to vourter interface mapping")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_vrouter(self):
gsc_obj = self._global_system_config_obj
if self._args.ip_fabric_subnet:
ip_subnet, mask = self._args.ip_fabric_subnet.split('/')
so = SubnetType(ip_subnet, int(mask))
sl = gsc_obj.get_ip_fabric_subnets()
if sl is None:
gsc_obj.set_ip_fabric_subnets(SubnetListType([so]))
self._vnc_lib.global_system_config_update(gsc_obj)
elif so not in sl.subnet:
sl.subnet.append(so)
gsc_obj.set_ip_fabric_subnets(sl)
self._vnc_lib.global_system_config_update(gsc_obj)
vrouter_obj = VirtualRouter(
self._args.host_name,
gsc_obj,
virtual_router_ip_address=self._args.host_ip)
vrouter_exists = True
try:
vrouter_obj = self._vnc_lib.virtual_router_read(
fq_name=vrouter_obj.get_fq_name())
except NoIdError:
vrouter_exists = False
if self._args.sub_cluster_name:
sub_cluster_obj = SubCluster(self._args.sub_cluster_name)
try:
sub_cluster_obj = self._vnc_lib.sub_cluster_read(
fq_name=sub_cluster_obj.get_fq_name())
except NoIdError:
raise RuntimeError("Sub cluster has to be provisioned first")
vrouter_obj.add_sub_cluster(sub_cluster_obj)
# Configure router type
if self._args.router_type:
vrouter_obj.set_virtual_router_type(self._args.router_type)
if self._args.dpdk_enabled:
vrouter_obj.set_virtual_router_dpdk_enabled(True)
else:
vrouter_obj.set_virtual_router_dpdk_enabled(False)
# Configure sirov physical networks
if self._args.sriov_physnets:
vrouter_obj.set_virtual_router_sriov_physical_networks(
self._args.sriov_physnets)
if vrouter_exists:
self.vrouter_fq_name = vrouter_obj.get_fq_name()
self._vnc_lib.virtual_router_update(vrouter_obj)
else:
try:
self.vrouter_fq_name = vrouter_obj.get_fq_name()
self._vnc_lib.virtual_router_create(vrouter_obj)
except RefsExistError:
print("Already created!")
# end add_vrouter
def add_vhost0_vmi(self):
vrouter_exists = True
try:
vrouter_obj = self._vnc_lib.virtual_router_read(
fq_name=self.vrouter_fq_name)
except NoIdError:
vrouter_exists = False
if not vrouter_exists:
print("No vrouter object found cannot add vhost0 vmi !")
return
try:
vhost0_vmi_fq_name = self.vrouter_fq_name
vhost0_vmi_fq_name.append('vhost0')
vhost0_vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name=vhost0_vmi_fq_name)
vhost0_vmi_exists = True
except NoIdError:
vhost0_vmi_exists = False
vhost0_vmi = VirtualMachineInterface(name="vhost0",
parent_obj=vrouter_obj)
ip_fab_vn = self._vnc_lib.virtual_network_read(
fq_name=[u'default-domain', u'default-project', u'ip-fabric'])
vhost0_vmi.set_virtual_network(ip_fab_vn)
# Enable/Disable policy on the vhost0 vmi
if self._args.enable_vhost_vmi_policy:
vhost0_vmi.set_virtual_machine_interface_disable_policy(False)
else:
vhost0_vmi.set_virtual_machine_interface_disable_policy(True)
if vhost0_vmi_exists:
self._vnc_lib.virtual_machine_interface_update(vhost0_vmi)
else:
try:
self._vnc_lib.virtual_machine_interface_create(vhost0_vmi)
except RefsExistError:
print("vhost0 vmi already created!")
# end add_vhost0_vmi
def del_vrouter(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(self._args.host_name, gsc_obj)
vrouter_exists = True
try:
self._vnc_lib.virtual_router_read(
fq_name=vrouter_obj.get_fq_name())
except NoIdError:
vrouter_exists = False
if vrouter_exists:
self._vnc_lib.virtual_router_delete(
fq_name=vrouter_obj.get_fq_name())
else:
print(" vrouter object not found ")
# end del_vrouter
def del_vhost0_vmi(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(self._args.host_name, gsc_obj)
vhost0_vmi_fq_name = vrouter_obj.get_fq_name()
vhost0_vmi_fq_name.append('vhost0')
vhost0_vmi_exists = True
try:
self._vnc_lib.virtual_machine_interface_read(
fq_name=vhost0_vmi_fq_name)
except NoIdError:
vhost0_vmi_exists = False
if vhost0_vmi_exists:
self._vnc_lib.virtual_machine_interface_delete(
fq_name=vhost0_vmi_fq_name)
print(" Deleted vhost0 vmi %s " % vhost0_vmi_fq_name)
else:
print(" No vhost0 vmi found ")
class VrouterProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
rt_inst_obj = self._vnc_lib.routing_instance_read(
fq_name=['default-domain', 'default-project',
'ip-fabric', '__default__'])
self._fab_rt_inst_obj = rt_inst_obj
if self._args.oper == 'add':
self.add_vrouter()
if not self._args.disable_vhost_vmi:
self.add_vhost0_vmi()
elif self._args.oper == 'del':
self.del_vhost0_vmi()
self.del_vrouter()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_vrouter.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
[--dpdk-enabled]
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'router_type': None,
'dpdk_enabled': False,
'disable_vhost_vmi': False,
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--host_name", help="hostname name of compute-node", required=True)
parser.add_argument("--host_ip", help="IP address of compute-node", required=True)
parser.add_argument(
"--control_names",
help="List of control-node names compute node connects to")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--oper", default='add',
help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenamt name for keystone admin user")
parser.add_argument(
"--openstack_ip", help="IP address of openstack node")
parser.add_argument(
"--router_type", help="Type of the virtual router (tor-service-node,embedded or none)")
parser.add_argument(
"--dpdk_enabled", action="store_true", help="Whether forwarding mode on vrouter is DPDK based")
parser.add_argument(
"--disable_vhost_vmi", action="store_true", help="Do not create vhost0 vmi if flag is set")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server",
nargs='+', type=str)
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_vrouter(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(
self._args.host_name, gsc_obj,
virtual_router_ip_address=self._args.host_ip)
vrouter_exists = True
try:
vrouter_obj = self._vnc_lib.virtual_router_read(
fq_name=vrouter_obj.get_fq_name())
except NoIdError:
vrouter_exists = False
# Configure router type
if self._args.router_type:
vrouter_obj.set_virtual_router_type(self._args.router_type)
if self._args.dpdk_enabled:
vrouter_obj.set_virtual_router_dpdk_enabled(True)
else:
vrouter_obj.set_virtual_router_dpdk_enabled(False)
if vrouter_exists:
self.vrouter_fq_name = vrouter_obj.get_fq_name()
self._vnc_lib.virtual_router_update(vrouter_obj)
else:
try:
self.vrouter_fq_name = vrouter_obj.get_fq_name()
self._vnc_lib.virtual_router_create(vrouter_obj)
except RefsExistError:
print "Already created!"
# end add_vrouter
def add_vhost0_vmi(self):
vrouter_exists = True
try:
vrouter_obj = self._vnc_lib.virtual_router_read(
fq_name=self.vrouter_fq_name)
except NoIdError:
vrouter_exists = False
if not vrouter_exists:
print "No vrouter object found cannot add vhost0 vmi !"
return
vhost0_vmi_fq_name = self.vrouter_fq_name
vhost0_vmi_fq_name.append('vhost0')
vhost0_vmi_exists = True
vhost0_vmi = VirtualMachineInterface(name="vhost0", parent_obj = vrouter_obj)
ip_fab_vn = self._vnc_lib.virtual_network_read(fq_name = [u'default-domain', u'default-project', u'ip-fabric'])
vhost0_vmi.set_virtual_network(ip_fab_vn)
# Disable policy on the vhost0 vmi
vhost0_vmi.set_virtual_machine_interface_disable_policy(True)
try:
vhost0_vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name = vhost0_vmi_fq_name)
except NoIdError:
vhost0_vmi_exists = False
if vhost0_vmi_exists:
self._vnc_lib.virtual_machine_interface_update(vhost0_vmi)
else:
try:
self._vnc_lib.virtual_machine_interface_create(vhost0_vmi)
except RefsExistError:
print "vhost0 vmi already created!"
# end add_vhost0_vmi
def del_vrouter(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(self._args.host_name, gsc_obj)
vrouter_exists = True
try:
vrouter = self._vnc_lib.virtual_router_read(
fq_name=vrouter_obj.get_fq_name())
except NoIdError:
vrouter_exists = False
if vrouter_exists:
self._vnc_lib.virtual_router_delete(
fq_name=vrouter_obj.get_fq_name())
else:
print " vrouter object not found "
# end del_vrouter
def del_vhost0_vmi(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(self._args.host_name, gsc_obj)
vhost0_vmi_fq_name = vrouter_obj.get_fq_name()
vhost0_vmi_fq_name.append('vhost0')
vhost0_vmi_exists = True
try:
vhost0_vmi = self._vnc_lib.virtual_machine_interface_read(
fq_name = vhost0_vmi_fq_name)
except NoIdError:
vhost0_vmi_exists = False
if vhost0_vmi_exists:
self._vnc_lib.virtual_machine_interface_delete(fq_name=vhost0_vmi_fq_name)
print " Deleted vhost0 vmi %s " % vhost0_vmi_fq_name
else:
print " No vhost0 vmi found "
class VNMtuProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.user,
self._args.password,
self._args.tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
mtu = int(self._args.mtu)
vn_id_got = self._args.virtual_network_id
if mtu < 256 or mtu > 9160:
print 'Mtu value should be between 256 and 9160'
sys.exit(1)
if vn_id_got is None:
print 'virtual_network_id is invalid'
sys.exit(1)
vn = None
try:
vn = self._vnc_lib.virtual_network_read(id=vn_id_got)
except NoIdError:
pass
if vn is not None:
vn.set_virtual_network_mtu(mtu)
self._vnc_lib.virtual_network_update(vn)
print "Virtual network mtu updated"
else:
print "No virtual network found"
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_mtu.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--virtual_network_id 242717c9-8e78-4c67-94a8-5fbef1f2f096
--mtu 1500
--tenant_name "admin"
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'control_names': [],
'mtu': '1500',
}
ksopts = {
'user': '******',
'password': '******',
'tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--virtual_network_id",
help=" UUID of the virtual network")
parser.add_argument("--tenant_name",
help="Tenant name for keystone admin user")
parser.add_argument("--user", help="Name of keystone admin user")
parser.add_argument("--password",
help="Password of keystone admin user")
parser.add_argument(
"--mtu",
help=
"VM interface mtu value.Valid range from 256 to 9160,default : 1500"
)
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class AlarmProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
api_server_use_ssl=self._args.api_server_use_ssl)
except ResourceExhaustionError: # haproxy throws 503
raise
for alarm in alarm_list:
kwargs = alarm
fq_name = alarm['fq_name']
alarm_obj = Alarm(**kwargs)
try:
self._vnc_lib.alarm_create(alarm_obj)
except AttributeError:
print("Invalid alarm config for %s" % (fq_name))
except RefsExistError:
print("alarm config %s already exists, updating" % (fq_name))
try:
# we need to keep id_perms field empty in the alarm object
# otherwise vnc-api expects a valid id_perms.uuid field.
# existing id_perms.description field in alarm config db will
# stay as is.
# create an alarm object without id_perms field.
del kwargs['id_perms']
alarm_obj2 = Alarm(**kwargs)
self._vnc_lib.alarm_update(alarm_obj2)
except AttributeError:
print("Invalid alarm config for %s" % (fq_name))
except Exception as e:
print("Failed to update alarm config %s - %s" %
(fq_name, str(e)))
else:
print("Updated alarm %s" % (fq_name))
except Exception as e:
print("Failed to create alarm config %s - %s" %
(fq_name, str(e)))
else:
print("Created alarm %s" % (fq_name))
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_alarm.py --api_server_ip localhost
--api_server_port 8082
--admin_user admin
--admin_password contrail123
--admin_tenant_name admin
--api_server_use_ssl False
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
parser = argparse.ArgumentParser(add_help=False)
args, remaining_argv = parser.parse_known_args(args_str.split())
parser.add_argument("--api_server_port",
default='8082',
help="Port of api server")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenant name for keystone admin user")
parser.add_argument("--api_server_use_ssl",
default=False,
help="Use SSL to connect with API server"),
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class ConfigNodeProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
if self._args.oper == 'add':
self.add_config_node()
elif self._args.oper == 'del':
self.del_config_node()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_config_node.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--host_name", help="hostname name of config node", required=True)
parser.add_argument("--host_ip", help="IP address of config node", required=True)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--oper", default='add',
help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenamt name for keystone admin user")
parser.add_argument(
"--openstack_ip", help="IP address of openstack node")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_config_node(self):
gsc_obj = self._global_system_config_obj
config_node_obj = ConfigNode(
self._args.host_name, gsc_obj,
config_node_ip_address=self._args.host_ip)
config_node_exists = True
try:
config_node_obj = self._vnc_lib.config_node_read(
fq_name=config_node_obj.get_fq_name())
except NoIdError:
config_node_exists = False
if config_node_exists:
self._vnc_lib.config_node_update(config_node_obj)
else:
self._vnc_lib.config_node_create(config_node_obj)
# end add_config_node
def del_config_node(self):
gsc_obj = self._global_system_config_obj
config_node_obj = ConfigNode(self._args.host_name, gsc_obj)
self._vnc_lib.config_node_delete(
fq_name=config_node_obj.get_fq_name())
class StaticRouteProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.user, self._args.password,
self._args.tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
prefix = self._args.prefix
vmi_id_got = self._args.virtual_machine_interface_id
route_table_name = self._args.route_table_name
try:
ip_nw = IPNetwork(prefix)
except AddrFormatError:
print 'Invalid ip address format'
sys.exit(1)
project_fq_name_str = 'default-domain:'+ self._args.tenant_name
project_fq_name = project_fq_name_str.split(':')
project_obj = self._vnc_lib.project_read(fq_name=project_fq_name)
route_table = RouteTableType(route_table_name)
route_table.set_route([])
intf_route_table = InterfaceRouteTable(
interface_route_table_routes = route_table,
parent_obj=project_obj,
name=route_table_name)
try:
route_table_obj = self._vnc_lib.interface_route_table_read(
fq_name = intf_route_table.get_fq_name())
intf_route_table_id = route_table_obj.uuid
except NoIdError:
if self._args.oper == 'del':
print "Route table %s does not exist" %(route_table_name)
sys.exit(1)
print "Creating Route table"
intf_route_table_id = self._vnc_lib.interface_route_table_create(
intf_route_table)
intf_route_table_obj = self._vnc_lib.interface_route_table_read(
id = intf_route_table_id)
if self._args.oper == 'add':
intf_route_table_obj = self.add_route(intf_route_table_obj, prefix)
elif self._args.oper == 'del':
intf_route_table_obj = self.del_route(intf_route_table_obj, prefix)
self._vnc_lib.interface_route_table_update(intf_route_table_obj)
#Update the VMI Object now
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id = vmi_id_got)
if self._args.oper == 'add':
vmi_obj.add_interface_route_table(intf_route_table_obj)
elif self._args.oper == 'del':
if self.is_route_table_empty(intf_route_table_obj):
vmi_obj.del_interface_route_table(intf_route_table_obj)
self._vnc_lib.virtual_machine_interface_update(vmi_obj)
# end __init__
def add_route(self, intf_route_table_obj, prefix):
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
routes = rt_routes.get_route()
found = False
for route in routes:
if route.prefix == prefix:
print "Prefix already present in Interface Route Table, not adding"
found = True
sys.exit(0)
if not found:
rt1 = RouteType(prefix = prefix)
routes.append(rt1)
intf_route_table_obj.set_interface_route_table_routes(rt_routes)
return intf_route_table_obj
#end add_route
def del_route(self, intf_route_table_obj, prefix):
# routes = intf_route_table_obj['interface_route_table_routes']['route']
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
routes = rt_routes.get_route()
found = False
for route in routes:
if route.prefix == prefix:
found = True
routes.remove(route)
if not found :
print "Prefix %s not found in Route table %s!" %( prefix, intf_route_table_obj.name)
sys.exit(1)
intf_route_table_obj.set_interface_route_table_routes(rt_routes)
return intf_route_table_obj
def is_route_table_empty(self, intf_route_table_obj):
rt_routes = intf_route_table_obj.get_interface_route_table_routes()
if len(rt_routes.get_route()) == 0 :
return True
else:
return False
#end is_route_table_empty
def _parse_args(self, args_str):
'''
Eg. python provision_static_route.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--prefix 2.2.2.0/24
--virtual_machine_interface_id 242717c9-8e78-4c67-94a8-5fbef1f2f096
--route_table_name "MyRouteTable"
--tenant_name "admin"
--oper <add | del>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'route_table_name': 'CustomRouteTable',
}
ksopts = {
'user': '******',
'password': '******',
'tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument(
"--prefix", help="IP Destination prefix to be updated in the Route", required=True)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--oper", default='add',
help="Provision operation to be done(add or del)")
parser.add_argument(
"--virtual_machine_interface_id", help="Next hop which is the UUID of the VMI(aka port-id)")
parser.add_argument(
"--tenant_name", help="Tenant name for keystone admin user")
parser.add_argument(
"--user", help="Name of keystone admin user")
parser.add_argument(
"--password", help="Password of keystone admin user")
parser.add_argument(
"--route_table_name", help="Route Table name. Default : CustomRouteTable")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class VncProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc_lib = self._vnc_lib
if self._args.op is None or self._args.op == 'add_basic':
router_external = False
if self._args.public_vrf_test is not None and self._args.public_vrf_test == 'True':
router_external = True
vxlan = None
if self._args.vxlan is not None:
vxlan = self._args.vxlan
self.add_physical_router_config(router_external, vxlan)
elif self._args.op == 'delete_basic':
print 'calling delete_physical_router_config\n'
self.delete_physical_router_config()
elif self._args.op == 'delete_fip_test':
print 'calling delete_physical_router_config: fip_test\n'
self.delete_bms_config()
elif self._args.op == 'fip_test':
print 'calling add_physical_router_config: fip_test\n'
self.add_bms_config()
# end __init__
def _get_ip_fabric_ri_obj(self):
# TODO pick fqname hardcode from common
rt_inst_obj = self._vnc_lib.routing_instance_read(
fq_name=['default-domain', 'default-project',
'ip-fabric', '__default__'])
return rt_inst_obj
# end _get_ip_fabric_ri_obj
def create_router(self, name, mgmt_ip, password):
bgp_router = BgpRouter(name, parent_obj=self._get_ip_fabric_ri_obj())
params = BgpRouterParams()
params.address = mgmt_ip
params.address_families = AddressFamilies(['route-target', 'inet-vpn', 'e-vpn',
'inet6-vpn'])
params.autonomous_system = 64512
params.vendor = 'mx'
params.identifier = mgmt_ip
bgp_router.set_bgp_router_parameters(params)
self._vnc_lib.bgp_router_create(bgp_router)
pr = PhysicalRouter(name)
pr.physical_router_management_ip = mgmt_ip
pr.physical_router_vendor_name = 'juniper'
pr.physical_router_product_name = 'mx'
pr.physical_router_vnc_managed = True
uc = UserCredentials('root', password)
pr.set_physical_router_user_credentials(uc)
pr.set_bgp_router(bgp_router)
pr_id = self._vnc_lib.physical_router_create(pr)
return bgp_router, pr
def add_physical_router_config(self, router_external = False, vxlan = None):
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is None:
ipam_obj = NetworkIpam('ipam1')
self._vnc_lib.network_ipam_create(ipam_obj)
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn1'])
except NoIdError:
pass
if vn1_obj is None:
vn1_obj = VirtualNetwork('vn1')
if router_external == True:
vn1_obj.set_router_external(True)
if vxlan is not None:
vn1_obj_properties = VirtualNetworkType()
vn1_obj_properties.set_vxlan_network_identifier(int(vxlan))
vn1_obj.set_virtual_network_properties(vn1_obj_properties)
vn1_obj.add_network_ipam(ipam_obj, VnSubnetsType([IpamSubnetType(SubnetType("10.0.0.0", 24))]))
vn1_uuid = self._vnc_lib.virtual_network_create(vn1_obj)
pr = None
try:
pr = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'a7-mx-80'])
except NoIdError:
pass
if pr is None:
bgp_router, pr = self.create_router('a7-mx-80', '10.84.63.133', 'abc123')
pr.set_virtual_network(vn1_obj)
self._vnc_lib.physical_router_update(pr)
pi = None
try:
pi = self._vnc_lib.physical_interface_read(fq_name=[u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5'])
except NoIdError:
pass
if pi is None:
pi = PhysicalInterface('ge-1/0/5', parent_obj = pr)
pi_id = self._vnc_lib.physical_interface_create(pi)
fq_name = ['default-domain', 'default-project', 'vmi1']
default_project = self._vnc_lib.project_read(fq_name=[u'default-domain', u'default-project'])
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is None:
vmi = VirtualMachineInterface(fq_name=fq_name, parent_type='project')
vmi.set_virtual_network(vn1_obj)
self._vnc_lib.virtual_machine_interface_create(vmi)
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5', u'ge-1/0/5.0'])
except NoIdError:
pass
if li is None:
li = LogicalInterface('ge-1/0/5.0', parent_obj = pi)
li.vlan_tag = 100
li.set_virtual_machine_interface(vmi)
li_id = self._vnc_lib.logical_interface_create(li)
# end
def delete_physical_router_config(self):
print 'delete_physical_router_config\n'
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5', u'ge-1/0/5.0'])
except NoIdError:
pass
if li is not None:
self._vnc_lib.logical_interface_delete(li.get_fq_name())
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is not None:
self._vnc_lib.virtual_machine_interface_delete(vmi.get_fq_name())
pi = None
try:
pi = self._vnc_lib.physical_interface_read(fq_name=[u'default-global-system-config', u'a7-mx-80', u'ge-1/0/5'])
except NoIdError:
pass
if pi is not None:
pi_id = self._vnc_lib.physical_interface_delete(pi.get_fq_name())
pr = None
try:
pr = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'a7-mx-80'])
except NoIdError:
pass
if pr is not None:
self._vnc_lib.physical_router_delete(pr.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[u'default-domain', u'default-project', u'ip-fabric', u'__default__', u'a7-mx-80'])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn1'])
except NoIdError:
pass
if vn1_obj is not None:
vn1_uuid = self._vnc_lib.virtual_network_delete(vn1_obj.get_fq_name())
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is not None:
self._vnc_lib.network_ipam_delete(ipam_obj.get_fq_name())
# end
#python provision_physical_router.py --api_server_ip 127.0.0.1 --api_server_port 8082 --admin_user admin --admin_password c0ntrail123 --admin_tenant_name default-domain --op delete_fip_test
def delete_bms_config(self):
pr = None
try:
pr = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'a2-mx-80'])
except NoIdError:
pass
if pr is not None:
self._vnc_lib.physical_router_delete(pr.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[u'default-domain', u'default-project', u'ip-fabric', u'__default__', u'a2-mx-80'])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
#TOR
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[u'default-global-system-config', u'qfx-1', u'xe-0/0/0', u'xe-0/0/0.0'])
except NoIdError:
pass
if li is not None:
li_id = self._vnc_lib.logical_interface_delete(li.get_fq_name())
ip_obj1 = None
try:
ip_obj1 = self._vnc_lib.instance_ip_read(fq_name=[u'inst-ip-1'])
except NoIdError:
pass
if ip_obj1 is not None:
self._vnc_lib.instance_ip_delete(ip_obj1.get_fq_name())
fip_obj = None
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name=[u'default-domain', u'default-project', u'vn-public', u'vn_public_fip_pool', u'fip-1'])
except NoIdError:
pass
if fip_obj is not None:
self._vnc_lib.floating_ip_delete(fip_obj.get_fq_name())
fip_pool = None
try:
fip_pool = self._vnc_lib.floating_ip_pool_read(fq_name=[u'default-domain', u'default-project', u'vn-public', u'vn_public_fip_pool'])
except NoIdError:
pass
if fip_pool is not None:
self._vnc_lib.floating_ip_pool_delete(fip_pool.get_fq_name())
pi_tor = None
try:
pi_tor = self._vnc_lib.physical_interface_read(fq_name=[u'default-global-system-config', u'qfx-1', u'xe-0/0/0'])
except NoIdError:
pass
if pi_tor is not None:
pi_tor_id = self._vnc_lib.physical_interface_delete(pi_tor.get_fq_name())
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is not None:
self._vnc_lib.virtual_machine_interface_delete(vmi.get_fq_name())
pr_tor = None
try:
pr_tor = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'qfx-1'])
except NoIdError:
pass
if pr_tor is not None:
self._vnc_lib.physical_router_delete(pr_tor.get_fq_name())
br = None
try:
br = self._vnc_lib.bgp_router_read(fq_name=[u'default-domain', u'default-project', u'ip-fabric', u'__default__', u'qfx-1'])
except NoIdError:
pass
if br is not None:
self._vnc_lib.bgp_router_delete(br.get_fq_name())
vn2_obj = None
try:
vn2_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn-public'])
except NoIdError:
pass
if vn2_obj is not None:
self._vnc_lib.virtual_network_delete(vn2_obj.get_fq_name())
ipam2_obj = None
try:
ipam2_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam2'])
except NoIdError:
pass
if ipam2_obj is not None:
self._vnc_lib.network_ipam_delete(ipam2_obj.get_fq_name())
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn-private'])
except NoIdError:
pass
if vn1_obj is not None:
vn1_uuid = self._vnc_lib.virtual_network_delete(vn1_obj.get_fq_name())
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is not None:
self._vnc_lib.network_ipam_delete(ipam_obj.get_fq_name())
# end
# python provision_physical_router.py --api_server_ip 127.0.0.1 --api_server_port 8082 --admin_user admin --admin_password c0ntrail123 --admin_tenant_name default-domain --op fip_test
def add_bms_config(self):
ipam_obj = None
try:
ipam_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam1'])
except NoIdError:
pass
if ipam_obj is None:
ipam_obj = NetworkIpam('ipam1')
self._vnc_lib.network_ipam_create(ipam_obj)
vn1_obj = None
try:
vn1_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn-private'])
except NoIdError:
pass
if vn1_obj is None:
vn1_obj = VirtualNetwork('vn-private')
vn1_obj.add_network_ipam(ipam_obj, VnSubnetsType([IpamSubnetType(SubnetType("10.0.0.0", 24))]))
vn1_uuid = self._vnc_lib.virtual_network_create(vn1_obj)
pr = None
try:
pr = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'a2-mx-80'])
except NoIdError:
pass
if pr is None:
bgp_router, pr = self.create_router('a2-mx-80', '10.84.7.253', 'abc123')
pr.add_virtual_network(vn1_obj)
junos_service_ports = JunosServicePorts()
junos_service_ports.service_port.append("si-0/0/0")
pr.set_physical_router_junos_service_ports(junos_service_ports)
pr.physical_router_vendor_name = 'juniper'
pr.physical_router_product_name = 'mx'
pr.physical_router_vnc_managed = True
self._vnc_lib.physical_router_update(pr)
#TOR
pr_tor = None
try:
pr_tor = self._vnc_lib.physical_router_read(fq_name=[u'default-global-system-config', u'qfx-1'])
except NoIdError:
pass
if pr_tor is None:
bgp_router2, pr_tor = self.create_router('qfx-1', '2.2.2.2', 'abc123')
pr_tor.set_virtual_network(vn1_obj)
pr_tor.physical_router_vendor_name = 'juniper'
pr_tor.physical_router_product_name = 'qfx'
pr_tor.physical_router_vnc_managed = False
self._vnc_lib.physical_router_update(pr_tor)
pi_tor = None
try:
pi_tor = self._vnc_lib.physical_interface_read(fq_name=[u'default-global-system-config', u'qfx-1', u'xe-0/0/0'])
except NoIdError:
pass
if pi_tor is None:
pi_tor = PhysicalInterface('xe-0/0/0', parent_obj = pr_tor)
pi_tor_id = self._vnc_lib.physical_interface_create(pi_tor)
fq_name = ['default-domain', 'default-project', 'vmi1']
default_project = self._vnc_lib.project_read(fq_name=[u'default-domain', u'default-project'])
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(fq_name=[u'default-domain', u'default-project', u'vmi1'])
except NoIdError:
pass
if vmi is None:
vmi = VirtualMachineInterface(fq_name=fq_name, parent_type='project')
vmi.set_virtual_network(vn1_obj)
self._vnc_lib.virtual_machine_interface_create(vmi)
li = None
try:
li = self._vnc_lib.logical_interface_read(fq_name=[u'default-global-system-config', u'qfx-1', u'xe-0/0/0', u'xe-0/0/0.0'])
except NoIdError:
pass
if li is None:
li = LogicalInterface('xe-0/0/0.0', parent_obj = pi_tor)
li.set_virtual_machine_interface(vmi)
li_id = self._vnc_lib.logical_interface_create(li)
ip_obj1 = None
try:
ip_obj1 = self._vnc_lib.instance_ip_read(fq_name=[u'inst-ip-1'])
except NoIdError:
pass
if ip_obj1 is None:
ip_obj1 = InstanceIp(name='inst-ip-1')
ip_obj1.set_virtual_machine_interface(vmi)
ip_obj1.set_virtual_network(vn1_obj)
ip_id1 = self._vnc_lib.instance_ip_create(ip_obj1)
ip_obj1 = self._vnc_lib.instance_ip_read(id=ip_id1)
ip_addr1 = ip_obj1.get_instance_ip_address()
ipam2_obj = None
try:
ipam2_obj = self._vnc_lib.network_ipam_read(fq_name=[u'default-domain', u'default-project', u'ipam2'])
except NoIdError:
pass
if ipam2_obj is None:
ipam2_obj = NetworkIpam('ipam2')
self._vnc_lib.network_ipam_create(ipam2_obj)
vn2_obj = None
try:
vn2_obj = self._vnc_lib.virtual_network_read(fq_name=[u'default-domain', u'default-project', u'vn-public'])
except NoIdError:
pass
if vn2_obj is None:
vn2_obj = VirtualNetwork('vn-public')
vn2_obj.set_router_external(True)
vn2_obj.add_network_ipam(ipam_obj, VnSubnetsType([IpamSubnetType(SubnetType("192.168.7.0", 24))]))
vn2_uuid = self._vnc_lib.virtual_network_create(vn2_obj)
pr.add_virtual_network(vn2_obj)
self._vnc_lib.physical_router_update(pr)
fip_pool = None
try:
fip_pool = self._vnc_lib.floating_ip_pool_read(fq_name=[u'default-domain', u'default-project', u'vn-public', u'vn_public_fip_pool'])
except NoIdError:
pass
if fip_pool is None:
fip_pool_name = 'vn_public_fip_pool'
fip_pool = FloatingIpPool(fip_pool_name, vn2_obj)
self._vnc_lib.floating_ip_pool_create(fip_pool)
fip_obj = None
try:
fip_obj = self._vnc_lib.floating_ip_read(fq_name=[u'default-domain', u'default-project', u'vn-public', u'vn_public_fip_pool', 'fip-1'])
except NoIdError:
pass
if fip_obj is None:
fip_obj = FloatingIp("fip-1", fip_pool)
fip_obj.set_virtual_machine_interface(vmi)
default_project = self._vnc_lib.project_read(fq_name=[u'default-domain', u'default-project'])
fip_obj.set_project(default_project)
fip_uuid = self._vnc_lib.floating_ip_create(fip_obj)
# end
def _parse_args(self, args_str):
'''
Eg. python provision_physical_router.py
--api_server_ip 127.0.0.1
--api_server_port 8082
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
#'public_vn_name': 'default-domain:'
#'default-project:default-virtual-network',
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument(
"--admin_user", help="Name of keystone admin user", required=True)
parser.add_argument(
"--admin_password", help="Password of keystone admin user", required=True)
parser.add_argument(
"--admin_tenant_name", help="Tenamt name for keystone admin user", required=True)
parser.add_argument(
"--op", help="operation (add_basic, delete_basic, fip_test)", required=True)
parser.add_argument(
"--public_vrf_test", help="operation (False, True)", required=False)
parser.add_argument(
"--vxlan", help="vxlan identifier", required=False)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class BgpProvisioner(object):
def __init__(self,
user,
password,
tenant,
api_server_ip,
api_server_port,
api_server_use_ssl=False,
use_admin_api=False,
sub_cluster_name=None,
peer_list=None):
self._admin_user = user
self._admin_password = password
self._admin_tenant_name = tenant
self._api_server_ip = api_server_ip
self._api_server_port = api_server_port
self._api_server_use_ssl = api_server_use_ssl
self._sub_cluster_name = sub_cluster_name
self._peer_list = peer_list
self._vnc_lib = VncApiAdmin(
use_admin_api,
self._admin_user,
self._admin_password,
self._admin_tenant_name,
self._api_server_ip,
self._api_server_port,
'/',
api_server_use_ssl=self._api_server_use_ssl)
# end __init__
def _get_rt_inst_obj(self):
vnc_lib = self._vnc_lib
# TODO pick fqname hardcode from common
rt_inst_obj = vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
return rt_inst_obj
# end _get_rt_inst_obj
def add_bgp_router(self,
router_type,
router_name,
router_ip,
router_asn,
address_families=[],
md5=None,
local_asn=None,
port=179):
if not address_families:
address_families = [
'route-target', 'inet-vpn', 'e-vpn', 'erm-vpn', 'inet6-vpn'
]
if router_type != 'control-node':
address_families.remove('erm-vpn')
if router_type != 'control-node':
if 'erm-vpn' in address_families:
raise RuntimeError("Only contrail bgp routers can support "
"family 'erm-vpn'")
bgp_addr_fams = AddressFamilies(address_families)
bgp_sess_attrs = [BgpSessionAttributes(address_families=bgp_addr_fams)]
bgp_sessions = [BgpSession(attributes=bgp_sess_attrs)]
bgp_peering_attrs = BgpPeeringAttributes(session=bgp_sessions)
rt_inst_obj = self._get_rt_inst_obj()
vnc_lib = self._vnc_lib
if router_type == 'control-node':
vendor = 'contrail'
elif router_type == 'router':
vendor = 'mx'
else:
vendor = 'unknown'
router_params = BgpRouterParams(router_type=router_type,
vendor=vendor,
autonomous_system=int(router_asn),
identifier=get_ip(router_ip),
address=get_ip(router_ip),
port=port,
address_families=bgp_addr_fams)
if md5:
md5 = {'key_items': [{'key': md5, "key_id": 0}], "key_type": "md5"}
router_params.set_auth_data(md5)
if local_asn:
local_asn = int(local_asn)
if local_asn <= 0 or local_asn > 65535:
raise argparse.ArgumentTypeError(
"local_asn %s must be in range (1..65535)" % local_asn)
router_params.set_local_autonomous_system(local_asn)
bgp_router_obj = BgpRouter(router_name,
rt_inst_obj,
bgp_router_parameters=router_params)
bgp_router_fq_name = bgp_router_obj.get_fq_name()
peer_list = self._peer_list
fqname_peer_list = None
fqname_peer_set = None
if peer_list is not None:
fqname_peer_list = []
fqname_peer_set = set()
for peer in peer_list:
peer_router_obj = BgpRouter(peer, rt_inst_obj)
try:
vnc_lib.bgp_router_create(peer_router_obj)
except RefsExistError as e:
pass
finally:
fqname_peer_list.append(peer_router_obj.get_fq_name())
fqname_peer_set.add(tuple(peer_router_obj.get_fq_name()))
try:
# full-mesh with existing bgp routers
if self._sub_cluster_name:
sub_cluster_obj = SubCluster(self._sub_cluster_name)
try:
sub_cluster_obj = self._vnc_lib.sub_cluster_read(
fq_name=sub_cluster_obj.get_fq_name())
except NoIdError:
raise RuntimeError("Sub cluster to be provisioned first")
bgp_router_obj.add_sub_cluster(sub_cluster_obj)
if fqname_peer_list:
bgp_router_obj.set_bgp_router_list(fqname_peer_list,
[bgp_peering_attrs] *
len(fqname_peer_list))
vnc_lib.bgp_router_create(bgp_router_obj)
except RefsExistError as e:
print("BGP Router " + pformat(bgp_router_fq_name) +
" already exists " + str(e))
cur_obj = vnc_lib.bgp_router_read(
fq_name=bgp_router_fq_name,
fields=['global_system_config_back_refs'])
changed = False
if cur_obj.bgp_router_parameters != router_params:
cur_obj.set_bgp_router_parameters(router_params)
changed = True
cur_bgp_router_set = {
tuple(x['to'])
for x in cur_obj.get_bgp_router_refs() or []
}
if peer_list is not None and fqname_peer_set != cur_bgp_router_set:
cur_obj.set_bgp_router_list(fqname_peer_list,
[bgp_peering_attrs] *
len(fqname_peer_list))
changed = True
if self._sub_cluster_name and not cur_obj.get_sub_cluster_refs():
cur_obj.add_sub_cluster(sub_cluster_obj)
changed = True
if changed:
vnc_lib.bgp_router_update(cur_obj)
bgp_router_obj = cur_obj
if (router_type == 'control-node'
and not bgp_router_obj.get_global_system_config_back_refs()):
gsc_obj = vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.add_bgp_router(bgp_router_obj)
vnc_lib.ref_relax_for_delete(gsc_obj.uuid, bgp_router_obj.uuid)
vnc_lib.global_system_config_update(gsc_obj)
# end add_bgp_router
def del_bgp_router(self, router_name):
rt_inst_obj = self._get_rt_inst_obj()
fq_name = rt_inst_obj.get_fq_name() + [router_name]
self._vnc_lib.bgp_router_delete(fq_name=fq_name)
# end del_bgp_router
def add_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
route_targets = net_obj.get_route_target_list()
if route_targets:
route_targets.add_route_target(rtgt_val)
else:
route_targets = RouteTargetList([rtgt_val])
net_obj.set_route_target_list(route_targets)
vnc_lib.virtual_network_update(net_obj)
# end add_route_target
def del_route_target(self, rt_inst_fq_name, router_asn,
route_target_number):
vnc_lib = self._vnc_lib
rtgt_val = "target:%s:%s" % (router_asn, route_target_number)
net_obj = vnc_lib.virtual_network_read(fq_name=rt_inst_fq_name[:-1])
if rtgt_val not in net_obj.get_route_target_list().get_route_target():
print("%s not configured for VN %s" %
(rtgt_val, rt_inst_fq_name[:-1]))
return
route_targets = net_obj.get_route_target_list()
route_targets.delete_route_target(rtgt_val)
if route_targets.get_route_target():
net_obj.set_route_target_list(route_targets)
else:
net_obj.set_route_target_list(None)
vnc_lib.virtual_network_update(net_obj)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.user, self._args.password,
self._args.tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
prefix = self._args.prefix
vmi_id_got = self._args.virtual_machine_interface_id
route_table_name = self._args.route_table_name
try:
ip_nw = IPNetwork(prefix)
except AddrFormatError:
print 'Invalid ip address format'
sys.exit(1)
project_fq_name_str = 'default-domain:'+ self._args.tenant_name
project_fq_name = project_fq_name_str.split(':')
project_obj = self._vnc_lib.project_read(fq_name=project_fq_name)
route_table = RouteTableType(route_table_name)
route_table.set_route([])
intf_route_table = InterfaceRouteTable(
interface_route_table_routes = route_table,
parent_obj=project_obj,
name=route_table_name)
try:
route_table_obj = self._vnc_lib.interface_route_table_read(
fq_name = intf_route_table.get_fq_name())
intf_route_table_id = route_table_obj.uuid
except NoIdError:
if self._args.oper == 'del':
print "Route table %s does not exist" %(route_table_name)
sys.exit(1)
print "Creating Route table"
intf_route_table_id = self._vnc_lib.interface_route_table_create(
intf_route_table)
intf_route_table_obj = self._vnc_lib.interface_route_table_read(
id = intf_route_table_id)
if self._args.oper == 'add':
intf_route_table_obj = self.add_route(intf_route_table_obj, prefix)
elif self._args.oper == 'del':
intf_route_table_obj = self.del_route(intf_route_table_obj, prefix)
self._vnc_lib.interface_route_table_update(intf_route_table_obj)
#Update the VMI Object now
vmi_obj = self._vnc_lib.virtual_machine_interface_read(id = vmi_id_got)
if self._args.oper == 'add':
vmi_obj.add_interface_route_table(intf_route_table_obj)
elif self._args.oper == 'del':
if self.is_route_table_empty(intf_route_table_obj):
vmi_obj.del_interface_route_table(intf_route_table_obj)
self._vnc_lib.virtual_machine_interface_update(vmi_obj)
class EncapsulationProvision(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
encap_obj = EncapsulationPrioritiesType(
encapsulation=self._args.encap_priority.split(","))
try:
current_config = self._vnc_lib.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj = GlobalVrouterConfig(
encapsulation_priorities=encap_obj,
vxlan_network_identifier_mode=self._args.
vxlan_vn_id_mode)
result = self._vnc_lib.global_vrouter_config_create(
conf_obj)
print 'Created.UUID is %s' % (result)
return
except RefsExistError:
print "Already created!"
current_linklocal = current_config.get_linklocal_services()
encapsulation_priorities = encap_obj
vxlan_network_identifier_mode = current_config.get_vxlan_network_identifier_mode(
)
if self._args.oper != "add":
encap_obj = EncapsulationPrioritiesType(encapsulation=[])
conf_obj = GlobalVrouterConfig(
linklocal_services=current_linklocal,
encapsulation_priorities=encap_obj)
else:
conf_obj = GlobalVrouterConfig(
linklocal_services=current_linklocal,
encapsulation_priorities=encapsulation_priorities,
vxlan_network_identifier_mode=self._args.vxlan_vn_id_mode)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print 'Updated.%s' % (result)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_encap.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--encap_priority "MPLSoUDP,MPLSoGRE,VXLAN"
--vxlan_vn_id_mode "automatic"
--oper <add | delete>
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'encap_priority': 'MPLSoUDP,MPLSoGRE,VXLAN',
'vxlan_vn_id_mode': 'automatic'
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--encap_priority",
help="List of Encapsulation priority",
required=True)
parser.add_argument("--vxlan_vn_id_mode",
help="Virtual Network id type to be used")
parser.add_argument(
"--oper",
default='add',
help="Provision operation to be done(add or delete)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenant name for keystone admin user")
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
if not self._args.encap_priority:
parser.error('encap_priority is required')
class ControlProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
if self._args.peer_list:
peer_list = self._args.peer_list.split(',')
else:
peer_list = None
if self._args.router_asn and not self._args.oper:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/',
api_server_use_ssl=self._args.api_server_use_ssl)
# Update global system config also with this ASN
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
gsc_obj.set_autonomous_system(self._args.router_asn)
if self._args.ibgp_auto_mesh is not None:
gsc_obj.set_ibgp_auto_mesh(self._args.ibgp_auto_mesh)
if self._args.set_graceful_restart_parameters == True:
gr_params = GracefulRestartParametersType()
gr_params.set_restart_time(
int(self._args.graceful_restart_time))
gr_params.set_long_lived_restart_time(
int(self._args.long_lived_graceful_restart_time))
gr_params.set_end_of_rib_timeout(
int(self._args.end_of_rib_timeout))
gr_params.set_enable(self._args.graceful_restart_enable)
gr_params.set_bgp_helper_enable(
self._args.graceful_restart_bgp_helper_enable)
gr_params.set_xmpp_helper_enable(
self._args.graceful_restart_xmpp_helper_enable)
gsc_obj.set_graceful_restart_parameters(gr_params)
self._vnc_lib.global_system_config_update(gsc_obj)
return
bp_obj = BgpProvisioner(
self._args.admin_user, self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip, self._args.api_server_port,
api_server_use_ssl=self._args.api_server_use_ssl,
use_admin_api=self._args.use_admin_api,
sub_cluster_name=self._args.sub_cluster_name,
peer_list=peer_list)
if self._args.oper == 'add':
if self._args.sub_cluster_name:
bp_obj.add_bgp_router('external-control-node',
self._args.host_name,
self._args.host_ip, self._args.router_asn,
self._args.address_families, self._args.md5,
self._args.local_autonomous_system,
self._args.bgp_server_port)
else:
bp_obj.add_bgp_router('control-node', self._args.host_name,
self._args.host_ip, self._args.router_asn,
self._args.address_families, self._args.md5,
self._args.local_autonomous_system,
self._args.bgp_server_port)
elif self._args.oper == 'del':
bp_obj.del_bgp_router(self._args.host_name)
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def gr_time_type(self, value):
time = int(value)
if time < 0 or time > 4095:
raise argparse.ArgumentTypeError("graceful_restart_time %s must be in range (0..4095)" % value)
return time
def llgr_time_type(self, value):
time = int(value)
if time < 0 or time > 16777215:
raise argparse.ArgumentTypeError("long_lived_graceful_restart_time %s must be in range (0..16777215)" % value)
return time
def _parse_args(self, args_str):
'''
Eg. python provision_control.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--router_asn 64512
--ibgp_auto_mesh|--no_ibgp_auto_mesh
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
--md5 <key value>|None(optional)
--bgp_server_port <port>|None(optional)
--local_autonomous_system <ASN value>|None(optional)
--graceful_restart_time 300
--long_lived_graceful_restart_time 300
--end_of_rib_timeout 300
--set_graceful_restart_parameters False
--graceful_restart_bgp_helper_enable False
--graceful_restart_xmpp_helper_enable False
--graceful_restart_enable False
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c", "--conf_file",
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'router_asn': '64512',
'bgp_server_port': 179,
'local_autonomous_system': None,
'ibgp_auto_mesh': None,
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': None,
'admin_user': None,
'admin_password': None,
'admin_tenant_name': None,
'md5' : None,
'graceful_restart_time': 300,
'long_lived_graceful_restart_time': 300,
'end_of_rib_timeout': 300,
'graceful_restart_bgp_helper_enable': False,
'graceful_restart_xmpp_helper_enable': False,
'graceful_restart_enable': False,
'set_graceful_restart_parameters': False,
'sub_cluster_name': None,
'peer_list':None,
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument(
"--host_name", help="hostname name of control-node")
parser.add_argument("--host_ip", help="IP address of control-node")
parser.add_argument(
"--router_asn", help="AS Number the control-node is in", required=True)
parser.add_argument(
"--bgp_server_port", help="BGP server port number (Default: 179)")
parser.add_argument(
"--local_autonomous_system", help="Local autonomous-system number used to peer contrail-control bgp speakers across different geographic locations")
parser.add_argument(
"--address_families", help="Address family list",
choices=["route-target", "inet-vpn", "e-vpn", "erm-vpn", "inet6-vpn"],
nargs="*", default=[])
parser.add_argument(
"--md5", help="Md5 config for the node")
parser.add_argument(
"--ibgp_auto_mesh", help="Create iBGP mesh automatically", dest='ibgp_auto_mesh', action='store_true')
parser.add_argument(
"--no_ibgp_auto_mesh", help="Don't create iBGP mesh automatically", dest='ibgp_auto_mesh', action='store_false')
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument(
"--oper",
help="Provision operation to be done(add or del)")
parser.add_argument(
"--admin_user", help="Name of keystone admin user")
parser.add_argument(
"--admin_password", help="Password of keystone admin user")
parser.add_argument(
"--admin_tenant_name", help="Tenamt name for keystone admin user")
parser.add_argument(
"--graceful_restart_time",
help="Graceful Restart Time in seconds (0..4095)",
type=self.gr_time_type, default=300,
required=False)
parser.add_argument(
"--long_lived_graceful_restart_time",
help="Long Lived Graceful Restart Time in seconds (0..16777215)",
type=self.llgr_time_type, default=300,
required=False)
parser.add_argument(
"--end_of_rib_timeout",
help="EndOfRib timeout value in seconds (0..4095)",
type=self.gr_time_type, default=300,
required=False)
parser.add_argument("--graceful_restart_bgp_helper_enable",
action='store_true',
help="Enable helper mode for BGP graceful restart")
parser.add_argument("--graceful_restart_xmpp_helper_enable",
action='store_true',
help="Enable helper mode for XMPP graceful restart")
parser.add_argument("--graceful_restart_enable",
action='store_true',
help="Enable Graceful Restart")
parser.add_argument("--set_graceful_restart_parameters",
action='store_true',
help="Set Graceful Restart Parameters")
parser.add_argument(
"--sub_cluster_name", help="sub cluster to associate to",
required=False)
parser.add_argument(
"--peer_list", help="list of control node names to peer",
required=False)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument(
"--api_server_ip", help="IP address of api server",
nargs='+', type=str)
group.add_argument("--use_admin_api",
default=False,
help = "Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
class VrouterProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
connected = False
tries = 0
while not connected:
try:
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
auth_host=self._args.openstack_ip,
api_server_use_ssl=self._args.api_server_use_ssl)
connected = True
except ResourceExhaustionError: # haproxy throws 503
if tries < 10:
tries += 1
time.sleep(3)
else:
raise
gsc_obj = self._vnc_lib.global_system_config_read(
fq_name=['default-global-system-config'])
self._global_system_config_obj = gsc_obj
rt_inst_obj = self._vnc_lib.routing_instance_read(fq_name=[
'default-domain', 'default-project', 'ip-fabric', '__default__'
])
self._fab_rt_inst_obj = rt_inst_obj
if self._args.oper == 'add':
self.add_vrouter()
elif self._args.oper == 'del':
self.del_vrouter()
else:
print "Unknown operation %s. Only 'add' and 'del' supported"\
% (self._args.oper)
# end __init__
def _parse_args(self, args_str):
'''
Eg. python provision_vrouter.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
[--dpdk-enabled]
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'router_type': None,
'dpdk_enabled': False,
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = ConfigParser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--host_name",
help="hostname name of compute-node",
required=True)
parser.add_argument("--host_ip",
help="IP address of compute-node",
required=True)
parser.add_argument(
"--control_names",
help="List of control-node names compute node connects to")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
default='add',
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--openstack_ip",
help="IP address of openstack node")
parser.add_argument(
"--router_type",
help=
"Type of the virtual router (tor-service-node,embedded or none)")
parser.add_argument(
"--dpdk_enabled",
action="store_true",
help="Whether forwarding mode on vrouter is DPDK based")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
# end _parse_args
def add_vrouter(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(
self._args.host_name,
gsc_obj,
virtual_router_ip_address=self._args.host_ip)
vrouter_exists = True
try:
vrouter_obj = self._vnc_lib.virtual_router_read(
fq_name=vrouter_obj.get_fq_name())
except NoIdError:
vrouter_exists = False
# Configure router type
if self._args.router_type:
vrouter_obj.set_virtual_router_type(self._args.router_type)
if self._args.dpdk_enabled:
vrouter_obj.set_virtual_router_dpdk_enabled(True)
else:
vrouter_obj.set_virtual_router_dpdk_enabled(False)
if vrouter_exists:
self._vnc_lib.virtual_router_update(vrouter_obj)
else:
try:
self._vnc_lib.virtual_router_create(vrouter_obj)
except RefsExistError:
print "Already created!"
# end add_vrouter
def del_vrouter(self):
gsc_obj = self._global_system_config_obj
vrouter_obj = VirtualRouter(self._args.host_name, gsc_obj)
self._vnc_lib.virtual_router_delete(fq_name=vrouter_obj.get_fq_name())
class GlobalVrouterConfigProvisioner(object):
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(
self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port,
'/',
api_server_use_ssl=self._args.api_server_use_ssl)
port_trans_pool_list = []
if self._args.snat_list:
port = None
protocol = None
for proto_port in self._args.snat_list:
port_count = ''
port_range_obj = None
protocol = proto_port.split(':')[0]
port = proto_port.split(':')[1]
if '-' in port:
port_range_obj = PortType(start_port=int(
port.split('-')[0]),
end_port=int(port.split('-')[1]))
else:
port_count = port
port_trans_pool_obj = PortTranslationPool(
protocol=protocol,
port_range=port_range_obj,
port_count=port_count)
port_trans_pool_list.append(port_trans_pool_obj)
port_trans_pools_obj = PortTranslationPools(port_trans_pool_list)
try:
current_config = self._vnc_lib.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
except Exception as e:
try:
if self._args.oper == "add":
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(port_trans_pools_obj)
result = self._vnc_lib.global_vrouter_config_create(
conf_obj)
print('Created.UUID is %s' % (result))
return
except RefsExistError:
print("Already created!")
existing_snat_pools = current_config.get_port_translation_pools()
if not existing_snat_pools:
existing_snat_pools = PortTranslationPools([])
if port_trans_pool_list:
for snat_pool in port_trans_pool_list:
if not self.check_dup_snat_pool(snat_pool,
existing_snat_pools):
existing_snat_pools.add_port_translation_pool(snat_pool)
if self._args.oper != "add":
conf_obj = GlobalVrouterConfig()
else:
conf_obj = GlobalVrouterConfig(
flow_export_rate=self._args.flow_export_rate)
conf_obj.set_port_translation_pools(existing_snat_pools)
result = self._vnc_lib.global_vrouter_config_update(conf_obj)
print('Updated.%s' % (result))
# end __init__
def check_dup_snat_pool(self, snat_pool, existing_snat_pools):
for pool_obj in existing_snat_pools.get_port_translation_pool():
if snat_pool.get_port_count() and pool_obj.get_port_count():
if snat_pool.get_port_count() == pool_obj.get_port_count() and \
snat_pool.get_protocol() == pool_obj.get_protocol():
return True
elif snat_pool.get_port_range() and pool_obj.get_port_range():
if snat_pool.get_protocol() == pool_obj.get_protocol() and \
snat_pool.get_port_range().start_port == pool_obj.get_port_range().start_port and \
snat_pool.get_port_range().end_port == pool_obj.get_port_range().end_port:
return True
return False
def _parse_args(self, args_str):
'''
Eg. python provision_global_vrouter_config.py
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--flow_export_rate 10
--oper <add | delete>
--snat_list tcp:6000-7000 udp:500
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'snat_list': None
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'admin'
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--flow_export_rate",
type=int,
required=True,
help="Flow export rate to the collector")
parser.add_argument(
"--oper",
default='add',
choices=['add', 'delete'],
help="Provision operation to be done(add or delete)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenant name for keystone admin user")
parser.add_argument(
"--snat_list",
help="Protocol port range or port count list for distributed snat",
nargs='+',
type=str)
group = parser.add_mutually_exclusive_group()
group.add_argument("--api_server_ip", help="IP address of api server")
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
