def set_status_error(self, job_input, error_info):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
if 'apl_table_rec_id' in job_input:
apl_table_rec_id = job_input['apl_table_rec_id']
# Get Error Information
try:
if hasattr(error_info, 'args'):
err_info = json.dumps(error_info.args)
else:
err_info = error_info.__str__()
except:
err_info = 'An unexpected error has occurred'
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(
self.job_config.REST_URI_APL)
params = {}
params['task_status'] = 9
params['update_id'] = operation_id
params['err_info'] = err_info
keys = [apl_table_rec_id]
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
elif 'group_rec_id' in job_input:
group_rec_id = job_input['group_rec_id']
# Get Error Information
try:
if hasattr(error_info, 'args'):
err_info = json.dumps(error_info.args)
else:
err_info = error_info.__str__()
except:
err_info = 'An unexpected error has occurred'
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_dc_group = self.get_db_endpoint(
self.job_config.REST_URI_WIM_DC_CON_GROUP)
params = {}
params['task_status'] = 9
params['update_id'] = operation_id
params['err_info'] = err_info
keys = [group_rec_id]
db_update.set_context(db_endpoint_dc_group, keys, params)
db_update.execute()
def __withdraw_license(self, job_input, node_id):
# Get JOB Input Parameters
operation_id = job_input['data']['operation_id']
# Get Endpoint(DB Client)
db_endpoint_license = self.get_db_endpoint(
self.job_config.REST_URI_LICENSE)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 2
params['node_id'] = node_id
params['delete_flg'] = 0
db_list.set_context(db_endpoint_license, params)
db_list.execute()
license_list = db_list.get_return_param()
# Update NAL_LICENSE_MNG(DB Client)
for rec in license_list:
keys = [rec['ID']]
params = {}
params['status'] = 3
params['tenant_name'] = ''
params['node_id'] = ''
params['update_id'] = operation_id
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
def __update_db_apl(self,
job_input,
apl_table_rec_id,
msa_device_id='',
node_detail={},
act_or_sby=''):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Update NAL_LICENSE_MNG(DB Client)
keys = [apl_table_rec_id]
params = {}
params['update_id'] = operation_id
if act_or_sby == 'act':
params['master_MSA_device_id'] = msa_device_id
params['device_detail_master'] = json.dumps(node_detail)
elif act_or_sby == 'sby':
params['slave_MSA_device_id'] = msa_device_id
params['device_detail_slave'] = json.dumps(node_detail)
else:
params['MSA_device_id'] = msa_device_id
params['node_detail'] = json.dumps(node_detail)
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
def __update_db_setup_result(self,
job_input, act_sby, db_info, setup_result):
device_detail_col = self.APL_DEVICE_DETAIL_COL[act_sby]
# Get JOB Input Parameters
operation_id = job_input['operation_id']
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Update NAL_APL_MNG(DB Client)
keys = [db_info['apl']['rec_id']]
params = {}
params['update_id'] = operation_id
params['default_gateway'] = setup_result['default_gateway']
params[device_detail_col] = setup_result['node_detail']
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
# Update NAL_PORT_MNG(DB Client)
keys = [db_info['port']['rec_id']]
params = {}
params['update_id'] = operation_id
params['msa_info'] = setup_result['msa_info']
db_update.set_context(db_endpoint_port, keys, params)
db_update.execute()
def __withdraw_global_ip(self, operation_id, global_ip):
# Get Endpoint(DB Client)
db_endpoint_global_ip = self.get_db_endpoint(
self.job_config.REST_URI_GLOBAL_IP)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_GLOBAL_IP_MNG(DB Client)
params = {}
params['status'] = 101
params['delete_flg'] = 0
params['global_ip'] = global_ip
db_list.set_context(db_endpoint_global_ip, params)
db_list.execute()
global_ip_list = db_list.get_return_param()
if len(global_ip_list) == 0:
raise SystemError('global_ip is already deleted.')
# Update NAL_GLOBAL_IP_MNG(DB Client)
keys = [global_ip_list[0]['ID']]
params = {}
params['status'] = 103
params['tenant_name'] = ''
params['node_id'] = ''
params['update_id'] = operation_id
db_update.set_context(db_endpoint_global_ip, keys, params)
db_update.execute()
def device_setup_create_vthunder(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT,
__name__, function_name, job_input)
# Get JOB Input Parameters
pod_id = job_input['pod_id']
apl_type = job_input['apl_type']
nf_type = job_input['type']
device_type = job_input['device_type']
# Get DeviceID
apl_data = self.__get_db_apl(job_input)
msa_device_id = apl_data['MSA_device_id']
# Get MSA Config
msa_config_for_common = self.get_msa_config_for_common(pod_id)
device_name = self.device_type_to_name(apl_type, nf_type, device_type)
msa_config_for_device = \
self.get_msa_config_for_device(pod_id, device_name)
# Setup System Common Setting
self.__setup_system_common_vthunder(job_input,
pod_id,
msa_device_id,
msa_config_for_common,
msa_config_for_device)
# Setup Tenant VLAN Setting
self.__setup_tenant_vlan_vthunder(job_input,
pod_id,
msa_device_id,
msa_config_for_common,
msa_config_for_device)
# Get Endpoint(DB Client)
db_endpoint = self.get_db_endpoint(self.job_config.REST_URI_APL)
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Update NAL_LICENSE_MNG(DB Client)
keys = [job_input['apl_table_rec_id']]
params = {}
params['update_id'] = job_input['operation_id']
params['default_gateway'] = job_input['fw_ip_address']
db_update.set_context(db_endpoint, keys, params)
db_update.execute()
# Set JOB Output Parameters
job_output = {}
# Output Log(Job Output)
self.output_log_job_params(self.LOG_TYPE_OUTPUT,
__name__, function_name, job_output)
return job_output
def __update_db_apl(self, job_input, node_detail_update):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
node_id = job_input['node_id']
# Get Endpoint(DB Client)
db_endpoint = self.get_db_endpoint(self.job_config.REST_URI_APL)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_VNF_MNG(DB Client)
params = {}
params['delete_flg'] = 0
params['node_id'] = node_id
db_list.set_context(db_endpoint, params)
db_list.execute()
apl_list = db_list.get_return_param()
node_detail_dict = json.loads(apl_list[0]['node_detail'])
node_detail_dict.update(node_detail_update)
# Update NAL_LICENSE_MNG(DB Client)
keys = [apl_list[0]['ID']]
params = {}
params['update_id'] = operation_id
params['node_detail'] = json.dumps(node_detail_dict)
db_update.set_context(db_endpoint, keys, params)
db_update.execute()
def __update_db_server_task_status_end(self, job_input):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
apl_table_rec_id = job_input['apl_table_rec_id']
license_key = job_input.get('license_key', '')
apl_type = job_input['apl_type']
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
if license_key == '' and \
str(apl_type) == str(self.job_config.APL_TYPE_VR):
params = {}
params['task_status'] = 2
params['update_id'] = operation_id
keys = [apl_table_rec_id]
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
else:
params = {}
params['task_status'] = 1
params['update_id'] = operation_id
keys = [apl_table_rec_id]
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
def __update_db_port(self, job_input, port_id, msa_info):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
nal_tenant_id = job_input['nal_tenant_id']
# Get Endpoint(DB Client)
db_endpoint = self.get_db_endpoint(self.job_config.REST_URI_PORT)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_VNF_MNG(DB Client)
params = {}
params['delete_flg'] = 0
params['tenant_id'] = nal_tenant_id
params['port_id'] = port_id
db_list.set_context(db_endpoint, params)
db_list.execute()
port_list = db_list.get_return_param()
# Update NAL_LICENSE_MNG(DB Client)
keys = [port_list[0]['ID']]
params = {}
params['update_id'] = operation_id
params['msa_info'] = json.dumps(msa_info)
db_update.set_context(db_endpoint, keys, params)
db_update.execute()
def update_db_license_status(self, device_type, status):
# Create Instance(DB Client)
db_list = list.ListClient(config.JobConfig())
db_update = update.UpdateClient(config.JobConfig())
# Get Endpoint(DB Client)
db_endpoint_license = \
base.JobAutoBase().get_db_endpoint(
config.JobConfig().REST_URI_LICENSE)
# Update NAL_LICENSE_MNG
params = {}
params['create_id'] = 'test_nw_automation_user_001'
params['type'] = 2
params['device_type'] = device_type
db_list.set_context(db_endpoint_license, params)
db_list.execute()
update_license_list = db_list.get_return_param()
for update_license in update_license_list:
keys = [update_license['ID']]
params = {}
params['status'] = status
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
def __get_device_endpoint_info(self, job_input):
# Get JOB Input Parameters
tenant_name = job_input['tenant_name']
pod_id = job_input['pod_id']
operation_id = job_input['operation_id']
dc_id = job_input.get('dc_id', 'system')
# Get Endpoint(DB Client)
db_endpoint_tenant = self.get_db_endpoint(
self.job_config.REST_URI_TENANT)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# Get Endpoint(OpenStack:VIM)
endpoint_config = self.nal_endpoint_config[dc_id]['vim'][pod_id]
admin_tenant_id = endpoint_config['admin_tenant_id']
admin_tenant_name = endpoint_config['admin_tenant_name']
# List NAL_TENANT_MNG(DB Client)
params = {}
params['tenant_name'] = tenant_name
params['delete_flg'] = 0
db_list_instance.set_context(db_endpoint_tenant, params)
db_list_instance.execute()
nal_tenant_list = db_list_instance.get_return_param()
if len(nal_tenant_list) == 0:
raise SystemError('tenant not exists.')
rec_id = nal_tenant_list[0]['ID']
tenant_info = json.loads(nal_tenant_list[0]['tenant_info'])
tenant_info_wk = {}
tenant_info_wk['pod_id'] = pod_id
tenant_info_wk['id'] = admin_tenant_id
tenant_info_wk['name'] = admin_tenant_name
tenant_info_wk['msa_customer_name'] = ''
tenant_info_wk['msa_customer_id'] = 0
tenant_info.append(tenant_info_wk)
# Update NAL_VNF_MNG(DB Client):Set DeleteFlg On
params = {}
params['update_id'] = operation_id
params['tenant_info'] = json.dumps(tenant_info)
keys = [rec_id]
db_update_instance.set_context(db_endpoint_tenant, keys, params)
db_update_instance.execute()
job_output = {
'nal_tenant_id': admin_tenant_id,
'nal_tenant_name': admin_tenant_name,
}
return job_output
def get_or_create_pod_tenant(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT, __name__,
function_name, job_input)
# Get JOB Input Parameters
operation_id = job_input['operation_id']
apl_table_rec_id = job_input.get('apl_table_rec_id', '')
hard_type = job_input.get('type', '')
vim_iaas_with_flg = self.get_vim_iaas_with_flg(job_input)
# Get Tenant(NAL)
os_tenant_info = self.__get_pod_tenant(job_input)
if len(os_tenant_info['nal_tenant_id']) == 0:
if vim_iaas_with_flg == 0:
# Set TenantInfo(NAL)/Create Tenant(NAL)
os_tenant_info = self.__create_pod_tenant(job_input)
else:
os_tenant_info = self.__get_device_endpoint_info(job_input)
else:
pass
if hard_type in ['1', '2']:
# Create Instance(DB Client)
db_update_instance = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(
self.job_config.REST_URI_APL)
# Update NAL_APL_MNG(DB Client) For Set PodID
keys = [apl_table_rec_id]
params = {}
params['update_id'] = operation_id
params['tenant_id'] = os_tenant_info['nal_tenant_id']
db_update_instance.set_context(db_endpoint_apl, keys, params)
db_update_instance.execute()
# Get JOB Output Parameters
job_output = {
'nal_tenant_id': os_tenant_info['nal_tenant_id'],
'nal_tenant_name': os_tenant_info['nal_tenant_name'],
}
# Output Log(Job Output)
self.output_log_job_params(self.LOG_TYPE_OUTPUT, __name__,
function_name, job_output)
return job_output
def _update_db_port(self, update_params, port_rec_id):
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
keys = [port_rec_id]
db_update.set_context(db_endpoint_port, keys, update_params)
db_update.execute()
def __get_apl_info(self, tenant_name, apl_table_rec_id):
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_APL_MNG(DB Client)
params = {}
params['tenant_name'] = tenant_name
params['ID'] = apl_table_rec_id
params['delete_flg'] = 0
db_list.set_context(db_endpoint_apl, params)
db_list.execute()
vnf_list = db_list.get_return_param()
if len(vnf_list) == 0:
raise SystemError('server not exists.')
# Update NAL_APL_MNG(DB Client)
params = {}
params['task_status'] = 0
keys = [vnf_list[0]['ID']]
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
vnf_output = {
'apl_table_rec_id':
vnf_list[0]['ID'],
'msa_device_id':
vnf_list[0]['MSA_device_id'],
'pod_id':
vnf_list[0]['pod_id'],
'apl_type':
vnf_list[0]['apl_type'],
'type':
vnf_list[0]['type'],
'device_type':
vnf_list[0]['device_type'],
'nal_tenant_id':
vnf_list[0]['tenant_id'],
'node_id':
vnf_list[0]['node_id'],
'redundant_configuration_flg':
vnf_list[0]['redundant_configuration_flg']
}
return vnf_output
def __delete_db_port_logical(self, operation_id, port_key_id):
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
params = {}
params['delete_flg'] = 1
params['update_id'] = operation_id
keys = [port_key_id]
db_update.set_context(db_endpoint_port, keys, params)
db_update.execute()
def virtual_rt_finalize_setting_update(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT, __name__,
function_name, job_input)
# Get JOB Input Parameters
operation_id = job_input['data']['operation_id']
virtual_apl_list = job_input['data']['virtual_apl_list']
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
# Create Instance(DB Client)
db_update_instance = update.UpdateClient(self.job_config)
for apl_data in virtual_apl_list:
# Update NAL_APL_MNG(DB Client)
params = {}
params['update_id'] = operation_id
params['node_detail'] = apl_data['node_detail']
if 'dns_server_ip_address' in apl_data:
params['dns_server_ip_address'] = \
apl_data['dns_server_ip_address']
if 'ntp_server_ip_address' in apl_data:
params['ntp_server_ip_address'] = \
apl_data['ntp_server_ip_address']
if 'snmp_server_ip_address' in apl_data:
params['snmp_server_ip_address'] = \
apl_data['snmp_server_ip_address']
if 'syslog_server_ip_address' in apl_data:
params['syslog_server_ip_address'] = \
apl_data['syslog_server_ip_address']
keys = [apl_data['apl_rec_id']]
db_update_instance.set_context(db_endpoint_apl, keys, params)
db_update_instance.execute()
# Output Log(Job Output)
job_output = {}
self.output_log_job_params(self.LOG_TYPE_OUTPUT, __name__,
function_name, job_output)
return job_output
def __update_db_server_task_status_end_for_update(self, job_input):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
apl_table_rec_id = job_input['apl_table_rec_id']
# Create Instance(DB Client)
db_update = update.UpdateClient(self.job_config)
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
params = {}
params['task_status'] = 1
params['update_id'] = operation_id
keys = [apl_table_rec_id]
db_update.set_context(db_endpoint_apl, keys, params)
db_update.execute()
def __assign_global_ip(self, tenant_name, operation_id):
# Get Endpoint(DB Client)
db_endpoint_global_ip = self.get_db_endpoint(
self.job_config.REST_URI_GLOBAL_IP)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_GLOBAL_IP_MNG(DB Client)
params = {}
params['delete_flg'] = 0
db_list.set_context(db_endpoint_global_ip, params)
db_list.execute()
global_ip_list = db_list.get_return_param()
global_ip = ''
for rec in global_ip_list:
if str(rec['status']) == '0':
key_id = rec['ID']
global_ip = rec['global_ip']
if len(global_ip) == 0:
for rec in global_ip_list:
if str(rec['status']) == '103' or \
str(rec['status']) == '203':
key_id = rec['ID']
global_ip = rec['global_ip']
if len(global_ip) == 0:
raise SystemError('global ip not found.')
# Update NAL_GLOBAL_IP_MNG(DB Client)
keys = [key_id]
params = {}
params['status'] = 101
params['tenant_name'] = tenant_name
params['update_id'] = operation_id
db_update.set_context(db_endpoint_global_ip, keys, params)
db_update.execute()
return global_ip
def finalize_dc_connect_vm(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT, __name__,
function_name, job_input)
# Get JOB Input Parameters
virtual_apl_list = job_input['data']['virtual_apl_list']
virtual_lan_list = job_input['data']['virtual_lan_list']
apl_port_list = job_input['data']['apl_port_list']
update_apl_port_list = job_input['data']['update_apl_port_list']
license_list = job_input['data'].get('license_list', [])
update_apl_wan_port_list = job_input['data'].get(
'update_apl_wan_port_list', [])
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
db_endpoint_vlan = self.get_db_endpoint(self.job_config.REST_URI_VLAN)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
db_endpoint_license = \
self.get_db_endpoint(self.job_config.REST_URI_LICENSE)
# Create Instance(DB Client)
db_create_instance = create.CreateClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# Create NAL_APL_MNG(DB Client)
for virtual_apl_data in virtual_apl_list:
params = {}
params['create_id'] = virtual_apl_data['create_id']
params['update_id'] = virtual_apl_data['update_id']
params['delete_flg'] = virtual_apl_data['delete_flg']
params['tenant_name'] = virtual_apl_data['tenant_name']
params['apl_type'] = virtual_apl_data['apl_type']
params['type'] = virtual_apl_data['type']
params['device_type'] = virtual_apl_data['device_type']
params['tenant_id'] = virtual_apl_data['tenant_id']
params['pod_id'] = virtual_apl_data['pod_id']
params['node_id'] = virtual_apl_data['node_id']
params['node_name'] = virtual_apl_data['node_name']
params['node_detail'] = virtual_apl_data['node_detail']
params['server_id'] = virtual_apl_data['server_id']
params['server_info'] = virtual_apl_data['server_info']
params['MSA_device_id'] = virtual_apl_data['MSA_device_id']
params['dns_server_ip_address'] = \
virtual_apl_data.get('dns_server_ip_address', '')
params['ntp_server_ip_address'] = \
virtual_apl_data.get('ntp_server_ip_address', '')
params['snmp_server_ip_address'] = \
virtual_apl_data.get('snmp_server_ip_address', '')
params['syslog_server_ip_address'] = \
virtual_apl_data.get('syslog_server_ip_address', '')
db_create_instance.set_context(db_endpoint_apl, params)
db_create_instance.execute()
# Create NAL_VIRTUAL_LAN_MNG(DB Client)
for virtual_lan_data in virtual_lan_list:
params = {}
params['create_id'] = virtual_lan_data['create_id']
params['update_id'] = virtual_lan_data['update_id']
params['delete_flg'] = virtual_lan_data['delete_flg']
params['tenant_name'] = virtual_lan_data['tenant_name']
params['tenant_id'] = virtual_lan_data['tenant_id']
params['network_id'] = virtual_lan_data['network_id']
params['pod_id'] = virtual_lan_data['pod_id']
params['vlan_id'] = virtual_lan_data['vlan_id']
params['IaaS_network_type'] \
= virtual_lan_data['IaaS_network_type']
params['IaaS_network_id'] \
= virtual_lan_data['IaaS_network_id']
params['IaaS_segmentation_id'] \
= virtual_lan_data['IaaS_segmentation_id']
params['rule_id'] = virtual_lan_data['rule_id']
params['nal_vlan_info'] = virtual_lan_data['nal_vlan_info']
db_create_instance.set_context(db_endpoint_vlan, params)
db_create_instance.execute()
# Create NAL_PORT_MNG(DB Client)
for apl_port_data in apl_port_list:
params = {}
params['create_id'] = apl_port_data['create_id']
params['update_id'] = apl_port_data['update_id']
params['delete_flg'] = apl_port_data['delete_flg']
params['tenant_name'] = apl_port_data['tenant_name']
params['tenant_id'] = apl_port_data['tenant_id']
params['apl_type'] = apl_port_data['apl_type']
params['port_id'] = apl_port_data['port_id']
params['IaaS_port_id'] = apl_port_data['IaaS_port_id']
params['node_id'] = apl_port_data['node_id']
params['network_id'] = apl_port_data['network_id']
params['nic'] = apl_port_data['nic']
params['ip_address'] = apl_port_data['ip_address']
params['netmask'] = apl_port_data['netmask']
params['ip_address_v6'] = apl_port_data.get('ip_address_v6', '')
params['netmask_v6'] = apl_port_data.get('netmask_v6', '')
params['port_info'] = apl_port_data['port_info']
params['msa_info'] = apl_port_data['msa_info']
params['network_type'] = apl_port_data['network_type']
params['network_type_detail'] = apl_port_data[
'network_type_detail']
db_create_instance.set_context(db_endpoint_port, params)
db_create_instance.execute()
# Update NAL_PORT_MNG(DB Client)
for apl_port_data in update_apl_port_list:
params = {}
params['update_id'] = apl_port_data['params']['update_id']
params['node_id'] = apl_port_data['params']['node_id']
params['nic'] = apl_port_data['params']['nic']
params['msa_info'] = apl_port_data['params']['msa_info']
keys = [apl_port_data['keys']['ID']]
db_update_instance.set_context(db_endpoint_port, keys, params)
db_update_instance.execute()
for apl_port_data in update_apl_wan_port_list:
params = {}
params['update_id'] = apl_port_data['params']['update_id']
params['msa_info'] = apl_port_data['params']['msa_info']
if 'ip_address_v6' in apl_port_data['params']:
params['ip_address_v6'] = apl_port_data['params'][
'ip_address_v6']
if 'netmask_v6' in apl_port_data['params']:
params['netmask_v6'] = apl_port_data['params']['netmask_v6']
if 'port_info' in apl_port_data['params']:
params['port_info'] = apl_port_data['params']['port_info']
keys = [apl_port_data['keys']['ID']]
db_update_instance.set_context(db_endpoint_port, keys, params)
db_update_instance.execute()
# Update NAL_LICENSE_MNG(DB Client)
for (license_id, apl_info) in zip(license_list, virtual_apl_list):
# Update NAL_LICENSE_MNG
keys = [license_id]
params = {}
params['node_id'] = apl_info['node_id']
db_update_instance.set_context(db_endpoint_license, keys, params)
db_update_instance.execute()
# Set JOB Output Parameters
job_output = {}
# Output Log(Job Output)
self.output_log_job_params(self.LOG_TYPE_OUTPUT, __name__,
function_name, job_output)
return job_output
def __assign_msa_network(self, tenant_name, pod_id, nal_tenant_id,
operation_id, job_input):
IaaS_tenant_id = job_input['IaaS_tenant_id']
vim_iaas_with_flg = self.get_vim_iaas_with_flg(job_input)
# Get Endpoint(DB Client)
db_endpoint_msa_vlan = self.get_db_endpoint(
self.job_config.REST_URI_MSA_VLAN)
# Get Endpoint(OpenStack:VIM)
os_endpoint_vim = self.get_os_endpoint_vim(pod_id, '', nal_tenant_id)
# Create Instance(OpenStack Client)
osc_networks = networks.OscQuantumNetworks(self.job_config)
os_subnets_instance = subnets.OscQuantumSubnets(self.job_config)
os_ports_instance = ports.OscQuantumPorts(self.job_config)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_MSA_VLAN_MNG(DB Client)
params = {}
params['delete_flg'] = 0
params['status'] = 0
db_list.set_context(db_endpoint_msa_vlan, params)
db_list.execute()
msa_vlan_list = db_list.get_return_param()
msa_network_info = {}
if len(msa_vlan_list) != 0:
rec = msa_vlan_list[0]
# Update NAL_MSA_VLAN_MNG(DB Client)
keys = [rec['ID']]
params = {}
params['update_id'] = operation_id
params['pod_id'] = pod_id
params['tenant_name'] = tenant_name
params['status'] = 1
params['tenant_id'] = nal_tenant_id
db_update.set_context(db_endpoint_msa_vlan, keys, params)
db_update.execute()
cidr = rec['network_address'] + '/' + rec['netmask']
if vim_iaas_with_flg == 0:
# Create Network(OpenStack:VIM)
network_name = 'MSA_for_' + nal_tenant_id
physical_network_name = None
else:
# Create Network(OpenStack:VIM)
network_name = 'MSA_for_' + IaaS_tenant_id
physical_network_name = self.get_os_physical_network_name()
os_cre_network_vim = osc_networks.create_network(
os_endpoint_vim, network_name, True, False, rec['vlan_id'],
physical_network_name)
network_info = os_cre_network_vim['network']
network_id = network_info['id']
# Get Network Data(id)
ret = self.utils.get_network_range_from_cidr(cidr)
gatewy_ip = \
socket.inet_ntoa(struct.pack('!L', ret['network'] + 1))
os_cre_subnet_vim = os_subnets_instance.create_subnet(
os_endpoint_vim, network_id, cidr, '', nal_tenant_id, '4',
gatewy_ip)
subnet_info = os_cre_subnet_vim['subnet']
subnet_id = subnet_info['id']
# Create Port(OpenStack:VIM)
os_cre_port_vim = os_ports_instance.create_port(
os_endpoint_vim, network_id)
# Get Port Info
port_info = os_cre_port_vim['port']
port_id = port_info['id']
ip_address = port_info['fixed_ips'][0]['ip_address']
# MSA setup
self.__setup_msa_network_vlan(pod_id, rec['vlan_id'], ip_address,
rec['netmask'])
# Update NAL_MSA_VLAN_MNG(DB Client)
keys = [rec['ID']]
params = {}
params['update_id'] = operation_id
params['msa_ip_address'] = ip_address
params['network_id'] = network_id
params['subnet_id'] = subnet_id
params['port_id'] = port_id
params['network_info'] = json.dumps(network_info)
params['subnet_info'] = json.dumps(subnet_info)
params['port_info'] = json.dumps(port_info)
db_update.set_context(db_endpoint_msa_vlan, keys, params)
db_update.execute()
# List NAL_MSA_VLAN_MNG(DB Client)
params = {}
params['delete_flg'] = 0
params['pod_id'] = pod_id
params['tenant_name'] = tenant_name
db_list.set_context(db_endpoint_msa_vlan, params)
db_list.execute()
msa_network_info = db_list.get_return_param()
else:
raise SystemError('vlan for MSA not Found.')
return msa_network_info
def __create_pod_tenant(self, job_input):
# Get JOB Input Parameters
tenant_name = job_input['tenant_name']
pod_id = job_input['pod_id']
iaas_tenant_name = job_input['IaaS_tenant_name']
operation_id = job_input['operation_id']
dc_id = job_input.get('dc_id', 'system')
# Get Endpoint(DB Client)
db_endpoint_tenant = self.get_db_endpoint(
self.job_config.REST_URI_TENANT)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# Get Endpoint(OpenStack:VIM)
endpoint_config = self.nal_endpoint_config[dc_id]['vim'][pod_id]
os_endpoint = self.get_os_endpoint_vim(
pod_id, '', endpoint_config['admin_tenant_id'], dc_id)
# Create Instance(OpenStack Client)
osc_tenants = tenants.OscTenants(self.job_config)
osc_roles = roles.OscRoles(self.job_config)
# Create Tenant(OpenStack Client)
os_tenant_res = osc_tenants.create_tenant(os_endpoint,
iaas_tenant_name)
# Add Admin Role To Tenant Admin User(OpenStack Client)
osc_roles.add_role_to_user(os_endpoint, endpoint_config['user_key'],
os_tenant_res['project']['id'],
endpoint_config['role_id'])
# List NAL_TENANT_MNG(DB Client)
params = {}
params['tenant_name'] = tenant_name
params['delete_flg'] = 0
db_list_instance.set_context(db_endpoint_tenant, params)
db_list_instance.execute()
nal_tenant_list = db_list_instance.get_return_param()
if len(nal_tenant_list) == 0:
raise SystemError('tenant not exists.')
rec_id = nal_tenant_list[0]['ID']
tenant_info = json.loads(nal_tenant_list[0]['tenant_info'])
tenant_info_wk = os_tenant_res['project']
tenant_info_wk['pod_id'] = pod_id
tenant_info_wk['msa_customer_name'] = ''
tenant_info_wk['msa_customer_id'] = 0
tenant_info.append(tenant_info_wk)
# Update NAL_VNF_MNG(DB Client):Set DeleteFlg On
params = {}
params['update_id'] = operation_id
params['tenant_info'] = json.dumps(tenant_info)
keys = [rec_id]
db_update_instance.set_context(db_endpoint_tenant, keys, params)
db_update_instance.execute()
job_output = {
'nal_tenant_id': os_tenant_res['project']['id'],
'nal_tenant_name': os_tenant_res['project']['name'],
}
return job_output
def main_create_vlb(self, job_input):
# tenant_id_convert
job_output = method.JobAutoMethod().tenant_id_convert(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertEqual(job_output['tenant_name'],
JOB_INPUT_CREATE['IaaS_tenant_id'])
# initialize_create_vnf
job_input.update(job_output)
job_output = method.JobAutoMethod().initialize_create_vnf(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertTrue('apl_table_rec_id' in job_output)
# routing_pod
job_input.update(job_output)
job_output = method.JobAutoMethod().routing_pod(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertEqual(job_output['pod_id'], 'pod_unit_test1')
# get_or_create_pod_tenant
job_input.update(job_output)
job_output = method.JobAutoMethod().get_or_create_pod_tenant(job_input)
# Assertion
self.assertEqual(len(job_output), 2)
self.assertTrue('nal_tenant_id' in job_output)
self.assertEqual(job_output['nal_tenant_name'],
JOB_INPUT_CREATE['IaaS_tenant_name'])
nal_tenant_id = job_output['nal_tenant_id']
db_list = list.ListClient(config.JobConfig())
db_update = update.UpdateClient(config.JobConfig())
# List NAL_PORT_MNG(DB Client)
db_endpoint_port = base.JobAutoBase().get_db_endpoint(
config.JobConfig().REST_URI_PORT)
params = {}
params['delete_flg'] = 0
db_list.set_context(db_endpoint_port, params)
db_list.execute()
port_list = db_list.get_return_param()
# Update NAL_PORT_MNG(DB Client)
for port_res in port_list:
keys = [port_res['ID']]
params = {}
params['tenant_id'] = nal_tenant_id
db_update.set_context(db_endpoint_port, keys, params)
db_update.execute()
# List NAL_VLAN_MNG(DB Client)
db_endpoint_vlan = base.JobAutoBase().get_db_endpoint(
config.JobConfig().REST_URI_VLAN)
params = {}
params['delete_flg'] = 0
db_list.set_context(db_endpoint_vlan, params)
db_list.execute()
vlan_list = db_list.get_return_param()
# Update NAL_VLAN_MNG(DB Client)
for vlan_res in vlan_list:
keys = [vlan_res['ID']]
params = {}
params['tenant_id'] = nal_tenant_id
db_update.set_context(db_endpoint_vlan, keys, params)
db_update.execute()
# hostname_check
job_input.update(job_output)
job_output = method.JobAutoMethod().hostname_check(job_input)
# Assertion
self.assertEqual(job_output, {})
# virtual_msa_port_create
job_input.update(job_output)
job_output = method.JobAutoMethod().virtual_msa_port_create(job_input)
# Assertion
self.assertEqual(len(job_output), 2)
self.assertTrue('port_id1' in job_output)
self.assertTrue('device_ip_address' in job_output)
# virtual_lb_tenant_vlan_port_create
job_input.update(job_output)
job_output = method.JobAutoMethod().\
virtual_lb_tenant_vlan_port_create(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertTrue('port_id4' in job_output)
# virtual_server_create
job_input.update(job_output)
job_output = method.JobAutoMethod()\
.virtual_server_create(job_input)
# Assertion
self.assertEqual(len(job_output), 2)
self.assertTrue('server_id' in job_output)
self.assertTrue('node_id' in job_output)
if job_input['device_type'] in ('1', ):
# license_assign
job_input.update(job_output)
job_output = method.JobAutoMethod().license_assign(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertEqual(job_output['license_key'], 'test_license_001')
elif job_input['device_type'] in ('2', ):
# license_assign_bigip_ve
job_input.update(job_output)
job_output = \
method.JobAutoMethod().license_assign_bigip_ve(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertEqual(job_output['license_key'], 'test_license_001')
elif job_input['device_type'] in ('3', ):
# zerotouch_vthunder
job_input.update(job_output)
job_output = \
method.JobAutoMethod().zerotouch_vthunder(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertEqual(job_output['license_key'], '')
# msa_customer_create
job_input.update(job_output)
job_output = method.JobAutoMethod().msa_customer_create(job_input)
# Assertion
self.assertEqual(len(job_output), 1)
self.assertTrue('msa_customer_id' in job_output)
# msa_setup_create
job_input.update(job_output)
job_output = method.JobAutoMethod().msa_setup_create(job_input)
# Assertion
self.assertEqual(len(job_output), 0)
self.assertEqual(job_output, {})
if job_input['device_type'] in ('1', ):
# device_setup_create_for_intersec_lb
job_input.update(job_output)
job_output = method.JobAutoMethod()\
.device_setup_create_for_intersec_lb(job_input)
# Assertion
self.assertEqual(len(job_output), 0)
self.assertEqual(job_output, {})
elif job_input['device_type'] in ('2', ):
# device_setup_create_for_bigip_ve
job_input.update(job_output)
job_output = method.JobAutoMethod()\
.device_setup_create_for_bigip_ve(job_input)
# Assertion
self.assertEqual(len(job_output), 0)
self.assertEqual(job_output, {})
elif job_input['device_type'] in ('3', ):
# device_setup_create_for_vthunder
job_input.update(job_output)
job_output = method.JobAutoMethod()\
.device_setup_create_for_vthunder(job_input)
# Assertion
self.assertEqual(len(job_output), 0)
self.assertEqual(job_output, {})
elif job_input['device_type'] in ('4', ):
# device_setup_create_for_vthunder411
job_input.update(job_output)
job_output = method.JobAutoMethod()\
.device_setup_create_for_vthunder411(job_input)
# Assertion
self.assertEqual(len(job_output), 0)
self.assertEqual(job_output, {})
# terminate_create_vnf
job_input.update(job_output)
job_output = method.JobAutoMethod().terminate_create_vnf(job_input)
# Assertion
self.assertEqual(len(job_output), 2)
self.assertEqual(job_output['result']['status'], 0)
self.assertEqual(job_output['result']['error-code'], '')
self.assertEqual(job_output['result']['message'], '')
self.assertEqual(job_output['data'], {})
job_input.update(job_output)
return job_input
def exec_through_vthunder411(self, iaas_network_type='VXLAN'):
device_type = '4'
# Create input data
job_input = copy.deepcopy(JOB_INPUT_CREATE)
job_input['IaaS_network_type'] = iaas_network_type
job_input['device_type'] = device_type
job_input['host_name'] = 'host_name_vthunder'
job_input['fw_ip_address'] = '10.58.10.1'
job_input['admin_id'] = 'admin_id'
job_input['admin_pw'] = 'admin_pw'
create_output = self.main_create_vlb(job_input)
# Get node_id from create process
node_id = create_output['node_id']
apl_table_rec_id = create_output['apl_table_rec_id']
port_id4 = create_output['port_id4']
# Create Instance(DB Client)
db_list = list.ListClient(config.JobConfig())
db_update = update.UpdateClient(config.JobConfig())
# Get Endpoint(DB Client)
db_endpoint_license = \
base.JobAutoBase().get_db_endpoint(
config.JobConfig().REST_URI_LICENSE)
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 0
params['type'] = 2
params['device_type'] = device_type
params['delete_flg'] = 0
db_list.set_context(db_endpoint_license, params)
db_list.execute()
license_list = db_list.get_return_param()
# Update NAL_LICENSE_MNG(DB Client)
if len(license_list) > 0:
keys = [license_list[0]['ID']]
params = {}
params['tenant_name'] = JOB_INPUT_CREATE['IaaS_tenant_id']
params['node_id'] = node_id
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
# Create input data
job_input = copy.deepcopy(JOB_INPUT_LICENSE)
job_input['device_type'] = device_type
job_input['node_id'] = node_id
self.main_license_assign_vlb(job_input)
# Create input data
job_input = copy.deepcopy(JOB_INPUT_ADD_IPV6)
job_input['device_type'] = device_type
job_input['node_id'] = node_id
job_input['port_id'] = port_id4
job_input['fw_ip_v6_address'] = '2001:db5::1'
self.main_add_ipv6_vlb(job_input)
# Create input data
job_input = copy.deepcopy(JOB_INPUT_DELETE)
job_input['device_type'] = device_type
job_input['node_id'] = node_id
job_input['apl_table_rec_id'] = apl_table_rec_id
self.main_delete_vlb(job_input)
def finalize_dc_disconnect_vm(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT, __name__,
function_name, job_input)
# Get JOB Input Parameters
logical_delete_apl_list = job_input['data']['logical_delete_apl_list']
logical_delete_apl_port_list \
= job_input['data']['logical_delete_apl_port_list']
logical_delete_vlan_list \
= job_input['data']['logical_delete_vlan_list']
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
db_endpoint_vlan = self.get_db_endpoint(self.job_config.REST_URI_VLAN)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# Update NAL_APL_MNG(DB Client)
for apl_data in logical_delete_apl_list:
params = {}
params['delete_flg'] = apl_data['search']['delete_flg']
params['tenant_id'] = apl_data['search']['tenant_id']
params['apl_type'] = apl_data['search']['apl_type']
params['type'] = apl_data['search']['type']
params['device_type'] = apl_data['search']['device_type']
params['node_id'] = apl_data['search']['node_id']
db_list_instance.set_context(db_endpoint_apl, params)
db_list_instance.execute()
apl_list = db_list_instance.get_return_param()
params = {}
params['update_id'] = apl_data['params']['update_id']
params['delete_flg'] = apl_data['params']['delete_flg']
keys = [apl_list[0]['ID']]
db_update_instance.set_context(db_endpoint_apl, keys, params)
db_update_instance.execute()
# Update NAL_PORT_MNG(DB Client)
for port_data in logical_delete_apl_port_list:
params = {}
params['delete_flg'] = port_data['search']['delete_flg']
params['tenant_id'] = port_data['search']['tenant_id']
params['apl_type'] = port_data['search']['apl_type']
params['port_id'] = port_data['search']['port_id']
db_list_instance.set_context(db_endpoint_port, params)
db_list_instance.execute()
port_list = db_list_instance.get_return_param()
params = {}
params['update_id'] = port_data['params']['update_id']
params['delete_flg'] = port_data['params']['delete_flg']
keys = [port_list[0]['ID']]
db_update_instance.set_context(db_endpoint_port, keys, params)
db_update_instance.execute()
# Update NAL_VIRTUAL_LAN_MNG(DB Client)
for vlan_data in logical_delete_vlan_list:
params = {}
params['delete_flg'] = vlan_data['search']['delete_flg']
params['tenant_id'] = vlan_data['search']['tenant_id']
params['network_id'] = vlan_data['search']['network_id']
db_list_instance.set_context(db_endpoint_vlan, params)
db_list_instance.execute()
vlan_list = db_list_instance.get_return_param()
params = {}
params['update_id'] = vlan_data['params']['update_id']
params['delete_flg'] = vlan_data['params']['delete_flg']
keys = [vlan_list[0]['ID']]
db_update_instance.set_context(db_endpoint_vlan, keys, params)
db_update_instance.execute()
# Set JOB Output Parameters
job_output = {}
# Output Log(Job Output)
self.output_log_job_params(self.LOG_TYPE_OUTPUT, __name__,
function_name, job_output)
return job_output
def virtual_rt_finalize_bandwidth(self, job_input):
function_name = inspect.currentframe().f_code.co_name
# Output Log(Job Input)
self.output_log_job_params(self.LOG_TYPE_INPUT, __name__,
function_name, job_input)
# Get JOB Input Parameters
operation_id = job_input['data']['operation_id']
tenant_name = job_input['data']['tenant_name']
bandwidth = job_input['data']['bandwidth']
virtual_apl_list = job_input['data']['virtual_apl_list']
license_list = job_input['data']['license_list']
# Get Endpoint(DB Client)
db_endpoint_apl = self.get_db_endpoint(self.job_config.REST_URI_APL)
db_endpoint_license = self.get_db_endpoint(
self.job_config.REST_URI_LICENSE)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
for (license_id, apl_data) in zip(license_list, virtual_apl_list):
# Update NAL_APL_MNG(DB Client)
params = {}
params['update_id'] = operation_id
params['node_detail'] = apl_data['node_detail']
keys = [apl_data['apl_rec_id']]
db_update_instance.set_context(db_endpoint_apl, keys, params)
db_update_instance.execute()
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['node_id'] = apl_data['node_id']
params['tenant_name'] = tenant_name
params['status'] = '2'
params['delete_flg'] = 0
db_list_instance.set_context(db_endpoint_license, params)
db_list_instance.execute()
license_list = db_list_instance.get_return_param()
# Update NAL_LICENSE_MNG(DB Client)
keys = [license_list[0]['ID']]
params = {}
params['update_id'] = operation_id
params['node_id'] = ''
params['tenant_name'] = ''
params['status'] = '3'
db_update_instance.set_context(db_endpoint_license, keys, params)
db_update_instance.execute()
# Update NAL_LICENSE_MNG(DB Client)
keys = [license_id]
params = {}
params['update_id'] = operation_id
params['node_id'] = apl_data['node_id']
db_update_instance.set_context(db_endpoint_license, keys, params)
db_update_instance.execute()
# Output Log(Job Output)
job_output = {}
self.output_log_job_params(self.LOG_TYPE_OUTPUT, __name__,
function_name, job_output)
return job_output
from job.conf import config
from job.lib.db import update
end_point = 'http://localhost:80/index.py/pnfs'
ids = [62]
params = {
# 'delete_flg': 0,
# 'type': 1,
# 'device_type': 2,
'status': 4,
# 'device_id': 'dev0001',
# 'redundant_configuration_flg': 1,
# 'device_name_master': 'master001',
# 'actsby_flag_master': 'act001',
# 'device_detail_master': 'detail001',
# 'master_ip_address': '10.0.0.1'
}
client = update.UpdateClient(config.JobConfig())
client.set_context(end_point, ids, params)
client.execute()
result = client.get_return_param()
print(type(result))
print(result)
def __delete_vlan(self, job_input, target_network_list):
# Get JOB Input Parameters
nal_tenant_id = job_input['data']['nal_tenant_id']
operation_id = job_input['data']['operation_id']
pod_id = job_input['data']['pod_id']
dc_id = job_input['data'].get('dc_id', 'system')
job_cleaning_mode = job_input['data'].get('job_cleaning_mode', '0')
# Get MSA Info(network_id)
msa_network_id = job_input['data']['msa_network_id']
# Get Network Info
pub_network_info = self.get_os_network_info(
pod_id, nal_tenant_id, self.job_config.NW_NAME_PUB, '', dc_id)
ext_network_info = self.get_os_network_info(
pod_id, nal_tenant_id, self.job_config.NW_NAME_EXT, '', dc_id)
network_id_list = [
msa_network_id, pub_network_info['network_id'],
ext_network_info['network_id']
]
if job_input['data']['group_type'] in [
str(self.job_config.GROUP_TYPE_CSRV_TUNNEL_ESP),
str(self.job_config.GROUP_TYPE_CSRV_TUNNEL_AH),
]:
idc_network_info = self.get_os_network_info(
pod_id, nal_tenant_id, self.job_config.NW_NAME_IDC, '', dc_id)
network_id_list.append(idc_network_info['network_id'])
# Get Endpoint(OpenStack:VIM)
os_endpoint_vim = self.get_os_endpoint_vim(pod_id, '', nal_tenant_id,
dc_id)
# Get Endpoint(DB Client)
db_endpoint_vlan = self.get_db_endpoint(self.job_config.REST_URI_VLAN)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
# Create Instance(OpenStack Client)
osc_networks = networks.OscQuantumNetworks(self.job_config)
# Create Instance(VXLAN-GW)
vxlangw_instance = vxlangw.VxlanGwClient(self.job_config)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# List NAL_VIRTUAL_LAN_MNG(DB)
params = {}
params['delete_flg'] = 0
params['pod_id'] = pod_id
params['nal_tenant_id'] = nal_tenant_id
db_list_instance.set_context(db_endpoint_vlan, params)
db_list_instance.execute()
vlan_list = db_list_instance.get_return_param()
for vlan_res in vlan_list:
vlan_rec_id = vlan_res['ID']
vlan_network_id = vlan_res['network_id']
iaas_network_type = vlan_res['IaaS_network_type']
rule_id = vlan_res['rule_id']
if vlan_network_id in network_id_list:
continue
if vlan_network_id not in target_network_list:
continue
# List NAL_PORT_MNG(DB)
params = {}
params['delete_flg'] = 0
params['pod_id'] = pod_id
params['nal_tenant_id'] = nal_tenant_id
params['network_id'] = vlan_network_id
db_list_instance.set_context(db_endpoint_port, params)
db_list_instance.execute()
port_list = db_list_instance.get_return_param()
if len(port_list) == 0:
try:
# Delete Network(OpenStack:VIM)
osc_networks.delete_network(os_endpoint_vim,
vlan_network_id)
except:
if job_cleaning_mode == '1':
self.output_log_fatal(__name__, traceback.format_exc())
else:
raise
# Delete VXLAN-GW Rule
if iaas_network_type.upper() == self.job_config.NW_TYPE_VXLAN:
params = [rule_id, self.job_config.PROV_TIMEOUT]
try:
vxlangw_instance.delete_vxlan_gw(params)
except:
if job_cleaning_mode == '1':
self.output_log_fatal(__name__,
traceback.format_exc())
else:
raise
# Update NAL_VIRTUAL_LAN_MNG(DB)
params = {}
params['update_id'] = operation_id
params['delete_flg'] = 1
keys = [vlan_rec_id]
db_update_instance.set_context(db_endpoint_vlan, keys, params)
db_update_instance.execute()
def __activation(self, job_input):
# Get JOB Input Parameters
operation_id = job_input['operation_id']
tenant_name = job_input['tenant_name']
pod_id = job_input['pod_id']
node_id = job_input['node_id']
apl_type = job_input['apl_type']
nf_type = job_input['type']
device_type = job_input['device_type']
vim_iaas_with_flg = self.get_vim_iaas_with_flg(job_input)
# Get Endpoint(DB Client)
db_endpoint_license = self.get_db_endpoint(
self.job_config.REST_URI_LICENSE)
db_endpoint_msa_vlan = \
self.get_db_endpoint(self.job_config.REST_URI_MSA_VLAN)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# Create Instance(Script Client)
license_instance = licenseauth.LicenseAuthClient(self.job_config)
# Get Vim Endpoint
vim_endpoint_data = self.nal_endpoint_config['system']['vim'][pod_id]
if vim_iaas_with_flg == 0:
server_login_password = vim_endpoint_data[
'openstack_controller_node_server_login_password']
nal_private_key_path = ''
else:
server_login_password = ''
nal_private_key_path = self.get_nal_private_key_path()
# Get MSA Config
device_name = self.device_type_to_name(apl_type, nf_type, device_type)
msa_config_for_device = \
self.get_msa_config_for_device(pod_id, device_name)
# Get MSA VLAN Data
params = {}
params['delete_flg'] = 0
params['tenant_name'] = tenant_name
params['pod_id'] = pod_id
db_list.set_context(db_endpoint_msa_vlan, params)
db_list.execute()
msa_vlan_list = db_list.get_return_param()
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 0
params['tenant_name'] = tenant_name
params['node_id'] = node_id
params['delete_flg'] = 0
db_list.set_context(db_endpoint_license, params)
db_list.execute()
license_list = db_list.get_return_param()
if len(license_list) == 0:
raise SystemError('license not found.')
else:
for rec in license_list:
# activetion(LicenseClient)
params = [
vim_endpoint_data['openstack_controller_node_ip_address'],
vim_endpoint_data[
'openstack_controller_node_server_login_id'],
server_login_password, nal_private_key_path,
vim_endpoint_data['openstack_keystone_ip_address'],
vim_endpoint_data['user_id'],
vim_endpoint_data['user_password'], node_id,
msa_config_for_device['user_id'],
msa_config_for_device['admin_password'],
msa_vlan_list[0]['msa_ip_address'], rec['license'],
vim_endpoint_data['admin_tenant_name'],
vim_endpoint_data['region_id']
]
passwords = [
vim_endpoint_data[
'openstack_controller_node_server_login_password'],
vim_endpoint_data['user_password'],
msa_config_for_device['admin_password'],
]
# Execute LicenseClient
if device_name == 'paloalto_vm':
license_instance.paloalto_authentication(params, passwords)
else:
license_instance.a10_vthunder_authentication(
params, passwords)
# Update NAL_LICENSE_MNG(DB Client)
keys = [rec['ID']]
params = {}
params['update_id'] = operation_id
params['status'] = 2
params['tenant_name'] = tenant_name
params['node_id'] = node_id
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
def _assign_license(self, job_input):
license_key = ''
# Get JOB Input Parameters
operation_id = job_input['operation_id']
tenant_name = job_input['tenant_name']
hard_type = job_input['type']
device_type = job_input['device_type']
node_id = job_input.get('node_id', '')
apl_type = job_input['apl_type']
nf_type = job_input['type']
dc_id = job_input.get('dc_id', 'system')
type_detail = job_input.get('license_type_detail', '')
# Get Config(Device Name)
device_name = self.device_type_to_name(apl_type, nf_type, device_type,
dc_id)
# Get Endpoint(DB Client)
db_endpoint_license = self.get_db_endpoint(
self.job_config.REST_URI_LICENSE)
# Create Instance(DB Client)
db_list = list.ListClient(self.job_config)
db_update = update.UpdateClient(self.job_config)
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 0
params['type'] = hard_type
params['device_type'] = device_type
params['delete_flg'] = 0
if len(type_detail) > 0:
params['type_detail'] = type_detail
db_list.set_context(db_endpoint_license, params)
db_list.execute()
license_list1 = db_list.get_return_param()
if len(license_list1) > 0:
# Update NAL_LICENSE_MNG(DB Client)
keys = [license_list1[0]['ID']]
params = {}
params['status'] = 2
params['tenant_name'] = tenant_name
params['update_id'] = operation_id
params['node_id'] = node_id
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
license_key = license_list1[0]['license']
license_id = license_list1[0]['ID']
else:
if device_name not in [
self.DEVICE_NAME_FORTIGATE_VM,
self.DEVICE_NAME_FORTIGATE_VM_541,
self.DEVICE_NAME_INTERSEC_SG,
self.DEVICE_NAME_INTERSEC_LB,
self.DEVICE_NAME_CSR1000V,
]:
raise SystemError('license not found.')
# List NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 3
params['type'] = hard_type
params['device_type'] = device_type
params['delete_flg'] = 0
if len(type_detail) > 0:
params['type_detail'] = type_detail
db_list.set_context(db_endpoint_license, params)
db_list.execute()
license_list2 = db_list.get_return_param()
if len(license_list2) == 0:
raise SystemError('license not found.')
check_date = (datetime.datetime.now()\
- datetime.timedelta(hours=4))\
.strftime('%Y-%m-%d %H:%M:%S')
fortgate_vm_license_found = False
for idx in range(len(license_list2)):
if device_name in [
self.DEVICE_NAME_FORTIGATE_VM,
self.DEVICE_NAME_FORTIGATE_VM_541,
]:
if check_date > license_list2[idx]['update_date']:
fortgate_vm_license_found = True
else:
continue
# Update NAL_LICENSE_MNG(DB Client)
params = {}
params['status'] = 2
params['tenant_name'] = tenant_name
params['update_id'] = operation_id
params['node_id'] = node_id
keys = [license_list2[idx]['ID']]
db_update.set_context(db_endpoint_license, keys, params)
db_update.execute()
license_key = license_list2[idx]['license']
license_id = license_list2[idx]['ID']
break
if device_name in [
self.DEVICE_NAME_FORTIGATE_VM,
self.DEVICE_NAME_FORTIGATE_VM_541,
] and fortgate_vm_license_found == False:
raise SystemError('license not found.')
if device_name == self.DEVICE_NAME_CSR1000V:
return license_id
else:
return license_key
def __add_port_tenant_ipv6(self, job_input, network_id, vlan_id):
output = {}
# Get JOB Input Parameters
operation_id = job_input['operation_id']
iaas_region_id = job_input['IaaS_region_id']
iaas_tenant_id = job_input['IaaS_tenant_id']
iaas_network_id = job_input['IaaS_network_id']
iaas_subnet_id = job_input['IaaS_subnet_id']
iaas_subnet_id_v6 = job_input['IaaS_subnet_id_v6']
pod_id = job_input['pod_id']
nal_tenant_id = job_input['nal_tenant_id']
vrrp_address = job_input['vrrp_address']
ce1_address = job_input['ce1_address']
ce2_address = job_input['ce2_address']
vim_iaas_with_flg = self.get_vim_iaas_with_flg(job_input)
# Get Endpoint(OpenStack:VIM)
os_endpoint_vim = self.get_os_endpoint_vim(pod_id, '', nal_tenant_id)
if vim_iaas_with_flg == 0:
iaas_token_tenant = iaas_tenant_id
else:
iaas_token_tenant = nal_tenant_id
# Get Endpoint(OpenStack:IaaS)
os_endpoint_iaas = self.get_os_endpoint_iaas(iaas_region_id, '',
iaas_token_tenant)
# Get Endpoint(DB Client)
db_endpoint_port = self.get_db_endpoint(self.job_config.REST_URI_PORT)
# Create Instance(OpenStack Client)
os_subnets_instance = subnets.OscQuantumSubnets(self.job_config)
os_ports_instance = ports.OscQuantumPorts(self.job_config)
# Create Instance(DB Client)
db_list_instance = list.ListClient(self.job_config)
db_update_instance = update.UpdateClient(self.job_config)
# Get Subnet(OpenStack:IaaS)
iaas_subnet_res = os_subnets_instance.get_subnet(
os_endpoint_iaas, iaas_subnet_id_v6)
iaas_cidr_wk = self.utils.get_cidr_compressed(
iaas_subnet_res['subnet']['cidr'])
iaas_cidr = iaas_cidr_wk['cidr']
subnet_ip_v6 = iaas_cidr_wk['ip']
netmask_v6 = iaas_cidr_wk['netmask']
# List NAL_PORT_MNG(DB)
params = {}
params['IaaS_tenant_id'] = iaas_tenant_id
params['IaaS_network_id'] = iaas_network_id
params['IaaS_subnet_id'] = iaas_subnet_id
params['delete_flg'] = 0
db_list_instance.set_context(db_endpoint_port, params)
db_list_instance.execute()
port_list_v4 = db_list_instance.get_return_param()
for port_res in port_list_v4:
if port_res['ip_address'] == vrrp_address:
port_vrrp = port_res
if port_res['ip_address'] == ce1_address:
port_ce1 = port_res
if port_res['ip_address'] == ce2_address:
port_ce2 = port_res
# Add IPv6 Tenant LAN(CE1,CE2)
for router_name, port_ce in {
self.job_config.VM_ROUTER_NODE_NAME1: port_ce1,
self.job_config.VM_ROUTER_NODE_NAME2: port_ce2,
}.items():
port_id_vim = port_ce['port_id']
port_id_iaas = port_ce['IaaS_port_id']
if vim_iaas_with_flg == 0:
# Get Port(OpenStack:IaaS)
iaas_port_res = os_ports_instance.get_port(
os_endpoint_iaas, port_id_iaas)
fixed_ips_iaas = iaas_port_res['port']['fixed_ips']
fixed_ips_iaas.append({'subnet_id': iaas_subnet_id_v6})
# Update Port(OpenStack:IaaS)
os_upd_port_iaas = os_ports_instance.update_port(
os_endpoint_iaas, port_id_iaas, None, None, fixed_ips_iaas)
fixed_ips_iaas = os_upd_port_iaas['port']['fixed_ips']
for fixed_ip in fixed_ips_iaas:
if fixed_ip['subnet_id'] == iaas_subnet_id_v6:
ip_address_v6 = self.utils.get_ipaddress_compressed(
fixed_ip['ip_address'])
break
# List Subnets(OpenStack:VIM)
subnet_list = os_subnets_instance.list_subnets(os_endpoint_vim)
subnet_exists_flg = False
subnet_id = ''
for rec in subnet_list['subnets']:
vim_cidr = self.utils.get_cidr_compressed(rec['cidr'])
if rec['network_id'] == network_id \
and vim_cidr['cidr'] == iaas_cidr:
subnet_exists_flg = True
subnet_id = rec['id']
break
if subnet_exists_flg == False:
# Create Subnet(OpenStack:VIM)
os_subnet_cre_vim = os_subnets_instance.create_subnet(
os_endpoint_vim, network_id, iaas_cidr, '',
nal_tenant_id, self.utils.IP_VER_V6)
subnet_id = os_subnet_cre_vim['subnet']['id']
# Get Port(OpenStack:VIM)
os_port_res_vim = os_ports_instance.get_port(
os_endpoint_vim, port_id_vim)
fixed_ips_vim = os_port_res_vim['port']['fixed_ips']
fixed_ips_vim.append({
'subnet_id': subnet_id,
'ip_address': ip_address_v6
})
# Update Port(OpenStack:VIM)
os_port_upd_vim = os_ports_instance.update_port(
os_endpoint_vim, port_id_vim, None, None, fixed_ips_vim)
else:
# Get Port(OpenStack:VIM)
vim_port_res = os_ports_instance.get_port(
os_endpoint_vim, port_id_vim)
fixed_ips_vim = vim_port_res['port']['fixed_ips']
fixed_ips_vim.append({'subnet_id': iaas_subnet_id_v6})
# Update Port(OpenStack:IaaS)
os_port_upd_vim = os_ports_instance.update_port(
os_endpoint_vim, port_id_vim, None, None, fixed_ips_vim)
fixed_ips_vim = os_port_upd_vim['port']['fixed_ips']
for fixed_ip in fixed_ips_vim:
if fixed_ip['subnet_id'] == iaas_subnet_id_v6:
ip_address_v6 = self.utils.get_ipaddress_compressed(
fixed_ip['ip_address'])
break
# Update NAL_PORT_MNG(DB Client)
keys = [port_ce['ID']]
params = {}
params['update_id'] = operation_id
params['IaaS_subnet_id_v6'] = iaas_subnet_id_v6
params['ip_address_v6'] = ip_address_v6
params['netmask_v6'] = netmask_v6
params['port_info'] = json.dumps(os_port_upd_vim['port'])
db_update_instance.set_context(db_endpoint_port, keys, params)
db_update_instance.execute()
# Set Output Parameters
output[router_name] = {}
output[router_name]['network_id'] = port_ce['network_id']
output[router_name]['port_id'] = port_id_vim
output[router_name]['ip_address'] = ip_address_v6
output[router_name]['netmask'] = netmask_v6
output[router_name]['rec_id'] = port_ce['ID']
output[router_name]['subnet_ip_address'] = subnet_ip_v6
output[router_name]['IaaS_subnet_id'] = iaas_subnet_id_v6
output[router_name]['vlan_id'] = vlan_id
output[router_name]['nic'] = port_ce['nic']
if vim_iaas_with_flg == 0:
vrrp_address = 'fe80::f' + format(int(vlan_id), 'x')
else:
if int(vlan_id) <= 65535:
vrrp_address = 'fe80::' + format(int(vlan_id), 'x')
else:
end_address = format(int(vlan_id), 'x')[-4:]
second_address = format(int(vlan_id), 'x')[:-4]
vrrp_address = 'fe80::' + second_address + ':' + end_address
# Set Output Parameters(vrrp)
output['vrrp'] = {}
output['vrrp']['network_id'] = port_vrrp['network_id']
output['vrrp']['port_id'] = port_vrrp['port_id']
output['vrrp']['ip_address'] = self.utils.get_ipaddress_compressed(
vrrp_address)
output['vrrp']['netmask'] = ''
output['vrrp']['rec_id'] = port_vrrp['ID']
output['vrrp']['subnet_ip_address'] = ''
output['vrrp']['IaaS_subnet_id'] = ''
output['vrrp']['vlan_id'] = vlan_id
return output
