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 created" % (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)
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.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)
vmi_id_got = self._args.virtual_machine_interface_id
if mtu < 256 or mtu > 9160:
print 'Mtu value should be between 256 and 9160'
sys.exit(1)
if vmi_id_got is None:
print 'virtual_machine_interface_id is invalid'
sys.exit(1)
vmi = None
try:
vmi = self._vnc_lib.virtual_machine_interface_read(id=vmi_id_got)
except NoIdError:
pass
if vmi is not None:
vmi.set_virtual_machine_interface_mtu(mtu)
self._vnc_lib.virtual_machine_interface_update(vmi)
print "Virtual machine interface mtu updated"
else:
print "No virtual machine interface found"
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,
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)
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.items():
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)
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,
self._args.local_autonomous_system)
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._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("GlobalVrouterConfig Exists Already!")
vrouter_conf_obj = self._vnc_lib.global_vrouter_config_read(
fq_name=global_vrouter_fq_name)
curr_encap_obj = vrouter_conf_obj.get_encapsulation_priorities(
)
print("Current Encap priority:", curr_encap_obj)
curr_vxlan_vn_id_mode = vrouter_conf_obj.get_vxlan_network_identifier_mode(
)
print("Current curr_vxlan_vn_id_mode priority:",
curr_vxlan_vn_id_mode)
vrouter_args = {}
if not curr_encap_obj:
vrouter_args['encapsulation_priorities'] = encap_obj
if not curr_vxlan_vn_id_mode:
vrouter_args[
'vxlan_network_identifier_mode'] = self._args.vxlan_vn_id_mode
if vrouter_args:
vrouter_args['fq_name'] = global_vrouter_fq_name
conf_obj = GlobalVrouterConfig(**vrouter_args)
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)
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)
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))
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, 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)
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
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()
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, 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_webui_node()
elif self._args.oper == 'del':
self.del_webui_node()
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)
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.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)