def validate_driver_types_missing_selectors(self, journal, validation_options, errors, warnings, descriptor_path):
if os.path.exists(descriptor_path):
descriptor = descriptor_utils.DescriptorParser().read_from_file(descriptor_path)
driver_entries_needing_fix = self.__gather_driver_types_missing_selector_key(journal, validation_options, errors, warnings, descriptor, 'lifecycle')
driver_entries_needing_fix.extend(self.__gather_driver_types_missing_selector_key(journal, validation_options, errors, warnings, descriptor, 'operations'))
if 'default-driver' in descriptor.raw and isinstance(descriptor.default_driver, dict):
for driver_type, driver_entry in descriptor.default_driver.items():
if 'infrastructure-type' in driver_entry:
driver_entries_needing_fix.append(driver_entry)
if len(driver_entries_needing_fix) > 0:
if validation_options.allow_autocorrect == True:
journal.event('Found lifecycle/operation/default-driver entries missing \'selector\' key before \'infrastructure-type\' [{0}], attempting to autocorrect by moving contents under a selector key'.format(descriptor_path))
managed_to_autocorrect = False
autocorrect_error = None
try:
for entry_needing_fix in driver_entries_needing_fix:
entry_needing_fix['selector'] = {'infrastructure-type': entry_needing_fix['infrastructure-type']}
entry_needing_fix.pop('infrastructure-type')
descriptor_utils.DescriptorParser().write_to_file(descriptor, descriptor_path)
managed_to_autocorrect = True
except Exception as e:
autocorrect_error = e
if not managed_to_autocorrect:
msg = 'Found lifecycle/operation/default-driver entries missing \'selector\' key before \'infrastructure-type\' [{0}]: Unable to autocorrect this issue, please add this information to the Resource descriptor manually instead'.format(descriptor_path)
if autocorrect_error is not None:
msg += ' (autocorrect error={0})'.format(str(autocorrect_error))
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
else:
msg = 'Found lifecycle/operation/default-driver entries missing \'selector\' key before \'infrastructure-type\' [{0}]: this format is no longer supported by the Brent Resource Manager. Move infrastructure-type information under the selector key or enable the autocorrect option'.format(descriptor_path)
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
def __pull_descriptor(self, journal, backup_tool, backup_tree, lm_session,
references):
journal.stage('Pulling descriptor for {0}'.format(
self.source_config.name))
descriptor_name = descriptors.descriptor_named(
descriptors.TYPE_DESCRIPTOR_TYPE, self.source_config.full_name,
self.source_config.version)
descriptor_driver = lm_session.descriptor_driver
journal.event('Pulling descriptor {0} from LM ({1})'.format(
descriptor_name, lm_session.env.address))
try:
raw_descriptor = descriptor_driver.get_descriptor(descriptor_name)
descriptor = descriptors.DescriptorParser().read_from_str(
raw_descriptor)
except lm_drivers.NotFoundException:
msg = 'Descriptor {0} not found'.format(descriptor_name)
journal.error_event(msg)
return
descriptor_path = self.tree.descriptor_file_path
if os.path.exists(descriptor_path):
self.__backup_descriptor(journal, backup_tool, backup_tree,
descriptor_path)
journal.event(
'Saving pulled descriptor to {0}'.format(descriptor_path))
descriptor = descriptor_mutations.DescriptorPullMutator(
references, journal).apply(descriptor)
descriptors.DescriptorParser().write_to_file(descriptor,
descriptor_path)
def validate_unsupported_infrastructure(self, journal, validation_options, errors, warnings, descriptor_path, inf_path, lifecycle_path):
if os.path.exists(descriptor_path):
descriptor = descriptor_utils.DescriptorParser().read_from_file(descriptor_path)
if 'infrastructure' in descriptor.raw and isinstance(descriptor.infrastructure, dict):
entry_needing_lifecycle_fix = []
entry_needing_discover_fix = []
for inf_type, inf_entry in descriptor.infrastructure.items():
if 'template' in inf_entry:
entry_needing_lifecycle_fix.append(inf_type)
if 'discover' in inf_entry:
entry_needing_discover_fix.append(inf_type)
if (len(entry_needing_lifecycle_fix) + len(entry_needing_discover_fix)) > 0:
if validation_options.allow_autocorrect == True:
journal.event('Found unsupported infrastructure entries referencing templates [{0}], attempting to autocorrect by moving contents to Create/Delete/queries entries in descriptor'.format(descriptor_path))
managed_to_autocorrect = False
autocorrect_error = None
try:
entry_needing_fix = entry_needing_lifecycle_fix + entry_needing_discover_fix
for inf_type in entry_needing_fix:
driver_type = inf_type
if inf_type == 'Openstack':
driver_type = 'openstack'
elif inf_type == 'Kubernetes':
driver_type = 'kubernetes'
target_lifecycle_path = os.path.join(lifecycle_path, driver_type)
if not os.path.exists(target_lifecycle_path):
os.makedirs(target_lifecycle_path)
inf_entry = descriptor.infrastructure[inf_type]
self.__move_template_files(inf_path, target_lifecycle_path, inf_type, inf_entry)
if inf_type in entry_needing_lifecycle_fix:
create_properties = None
if inf_type == 'Openstack' and inf_entry.get('template', {}).get('template-type') == 'TOSCA':
create_properties = {
'template-type': {
'value': inf_entry.get('template', {}).get('template-type')
}
}
self.__add_driver_to_lifecycle(descriptor, driver_type, inf_type, create_properties=create_properties)
if inf_type in entry_needing_discover_fix:
self.__add_driver_to_queries(descriptor, driver_type, inf_type)
descriptor.infrastructure[inf_type] = {}
descriptor_utils.DescriptorParser().write_to_file(descriptor, descriptor_path)
self.rename_inf_path = True
managed_to_autocorrect = True
except Exception as e:
autocorrect_error = e
raise
if not managed_to_autocorrect:
msg = 'Found unsupported infrastructure entries referencing templates [{0}]: this format is no longer supported by the Brent Resource Manager. Unable to autocorrect this issue, please add this information to the Create/Delete lifecycle and/or queries manually instead'.format(descriptor_path)
if autocorrect_error is not None:
msg += ' (autocorrect error={0})'.format(str(autocorrect_error))
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
else:
msg = 'Found infrastructure entries referencing templates [{0}]: this format is no longer supported by the Brent Resource Manager. Add this information to the Create/Delete lifecycle and/or queries instead or enable the autocorrect option'.format(descriptor_path)
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
def stage_descriptor(self,
orig_path,
relative_staging_path,
is_template=False):
staged_path = self.stage_file(orig_path, relative_staging_path)
descriptor = descriptor_utils.DescriptorParser().read_from_file(
staged_path)
descriptor = descriptor_mutations.DescriptorStageMutator(
self.source_config, self.references,
self.journal).apply(descriptor, is_template=is_template)
descriptor_utils.DescriptorParser().write_to_file(
descriptor, staged_path)
return staged_path
def __push_descriptor_template(self, journal, env_sessions):
lm_session = env_sessions.lm
descriptor_template_path = self.tree.descriptor_template_file_path
if os.path.exists(descriptor_template_path):
descriptor, descriptor_yml_str = descriptors.DescriptorParser(
).read_from_file_with_raw(descriptor_template_path)
descriptor_name = descriptor.get_name()
descriptor_template_driver = lm_session.descriptor_template_driver
journal.event(
'Checking for Descriptor Template {0} in LM ({1})'.format(
descriptor_name, descriptor_template_driver.lm_base))
found = True
try:
descriptor_template_driver.get_descriptor_template(
descriptor_name)
except lm_drivers.NotFoundException:
found = False
if found:
journal.event(
'Descriptor Template {0} already exists, updating'.format(
descriptor_name))
descriptor_template_driver.update_descriptor_template(
descriptor_name, descriptor_yml_str)
else:
journal.event(
'Not found, creating Descriptor Template {0}'.format(
descriptor_name))
descriptor_template_driver.create_descriptor_template(
descriptor_yml_str)
def __push_descriptor(self, journal, env_sessions):
lm_session = env_sessions.lm
descriptor_path = self.tree.descriptor_file_path
descriptor, descriptor_yml_str = descriptors.DescriptorParser(
).read_from_file_with_raw(descriptor_path)
descriptor_name = descriptor.get_name()
descriptor_driver = lm_session.descriptor_driver
journal.event('Checking for Descriptor {0} in LM ({1})'.format(
descriptor_name, lm_session.env.address))
found = True
try:
descriptor_driver.get_descriptor(descriptor_name)
except lm_drivers.NotFoundException:
found = False
if found:
journal.event('Descriptor {0} already exists, updating'.format(
descriptor_name))
descriptor_driver.update_descriptor(descriptor_name,
descriptor_yml_str)
else:
journal.event(
'Not found, creating Descriptor {0}'.format(descriptor_name))
descriptor_driver.create_descriptor(descriptor_yml_str)
env_sessions.mark_lm_updated()
return descriptor_name
def validate_descriptor(self, descriptor_path, errors, warnings, allow_autocorrect=False, is_template=False):
if not os.path.exists(descriptor_path):
msg = 'No descriptor found at: {0}'.format(descriptor_path)
self.journal.error_event(msg)
errors.append(validation.ValidationViolation(msg))
return
self.journal.event('Checking descriptor found at: {0}'.format(descriptor_path))
descriptor = None
try:
descriptor = descriptor_utils.DescriptorParser().read_from_file(descriptor_path)
except descriptor_utils.DescriptorParsingError as e:
errors.append(validation.ValidationViolation('Descriptor [{0}]: could not be parsed: {1}'.format(descriptor_path, str(e))))
else:
if descriptor.has_name() is True:
type_invalid = False
name_invalid = False
version_invalid = False
descriptor_type, descriptor_name, descriptor_version = descriptor.get_split_name()
expected_type = descriptor_utils.ASSEMBLY_DESCRIPTOR_TYPE
if is_template:
expected_type = descriptor_utils.ASSEMBLY_TEMPLATE_DESCRIPTOR_TYPE
if self.source_config.is_resource_project():
expected_type = descriptor_utils.RESOURCE_DESCRIPTOR_TYPE
elif self.source_config.is_type_project():
expected_type = descriptor_utils.TYPE_DESCRIPTOR_TYPE
if descriptor_type != expected_type:
errors.append(validation.ValidationViolation('Descriptor [{0}]: name \'{1}\' includes type \'{2}\' but this should be \'{3}\' based on project configuration'.format(descriptor_path, descriptor.get_name(),
descriptor_type, expected_type)))
if descriptor_name != self.source_config.full_name:
errors.append(validation.ValidationViolation('Descriptor [{0}]: name \'{1}\' includes \'{2}\' but this should be \'{3}\' based on project configuration'.format(descriptor_path, descriptor.get_name(),
descriptor_name, self.source_config.full_name)))
if descriptor_version != self.source_config.version:
errors.append(validation.ValidationViolation('Descriptor [{0}]: name \'{1}\' includes version \'{2}\' but this should be \'{3}\' based on project configuration'.format(descriptor_path, descriptor.get_name(),
descriptor_version, self.source_config.version)))
if type_invalid or name_invalid or version_invalid:
self.journal.error_event('Descriptor name validation failed')
if not isinstance(descriptor.lifecycle, dict) and allow_autocorrect is True:
self.journal.event('Found lifecycle list structure in Resource descriptor [{0}], attempting to autocorrect to latest structure'.format(descriptor_path))
new_lifecycle = {}
for lifecycle in descriptor.lifecycle:
new_lifecycle[lifecycle] = {}
descriptor.lifecycle = new_lifecycle
try:
descriptor_utils.DescriptorParser().write_to_file(descriptor, descriptor_path)
except Exception as e:
self.journal.error_event('Failed to update lifecycle list structure in Resource descriptor [{0}]: {1}'.format(descriptor_path, str(e)))
def __attempt_to_determine_version(self):
try:
potential_descriptor = os.path.join(self.root_path, 'Descriptor', 'assembly.yml')
if os.path.exists(potential_descriptor):
descriptor = descriptor_utils.DescriptorParser().read_from_file(potential_descriptor)
return descriptor.get_version()
except Exception as e:
return None
def __stage_descriptor(self, journal, source_stager, staging_tree):
descriptor_path = self.tree.descriptor_file_path
journal.stage('Staging type descriptor for {0} at {1}'.format(
self.source_config.name, descriptor_path))
staged_descriptor_path = source_stager.stage_descriptor(
descriptor_path, staging_tree.descriptor_file_path)
descriptor = descriptors.DescriptorParser().read_from_file(
staged_descriptor_path)
return descriptor.get_name()
def __validate_unsupported_infrastructure_manifest(self, journal, validation_options, errors, warnings):
inf_manifest_path = self.tree.infrastructure_manifest_file_path
if os.path.exists(inf_manifest_path):
if validation_options.allow_autocorrect == True:
journal.event('Found unsupported infrastructure manifest [{0}], attempting to autocorrect by moving contents to Resource descriptor'.format(inf_manifest_path))
managed_to_autocorrect = False
autocorrect_error = None
try:
with open(inf_manifest_path, 'r') as f:
inf_manifest_content = yaml.safe_load(f.read())
descriptor = descriptor_utils.DescriptorParser().read_from_file(self.get_main_descriptor())
descriptor.is_2_dot_1 = True
if 'templates' in inf_manifest_content:
for template_entry in inf_manifest_content['templates']:
if 'infrastructure_type' in template_entry:
infrastructure_type = template_entry['infrastructure_type']
template_file = template_entry.get('file', None)
template_type = template_entry.get('template_type', None)
descriptor.insert_infrastructure_template(infrastructure_type, template_file, template_type=template_type)
if 'discover' in inf_manifest_content:
for discover_entry in inf_manifest_content['discover']:
if 'infrastructure_type' in discover_entry:
infrastructure_type = discover_entry['infrastructure_type']
template_file = discover_entry.get('file', None)
template_type = discover_entry.get('template_type', None)
descriptor.insert_infrastructure_discover(infrastructure_type, template_file, template_type=template_type)
descriptor_utils.DescriptorParser().write_to_file(descriptor, self.get_main_descriptor())
os.rename(inf_manifest_path, inf_manifest_path + '.bak')
managed_to_autocorrect = True
except Exception as e:
autocorrect_error = e
if not managed_to_autocorrect:
msg = 'Found infrastructure manifest [{0}]: this file is no longer supported by the Brent Resource Manager. Unable to autocorrect this issue, please add this information to the Resource descriptor manually instead'.format(inf_manifest_path)
if autocorrect_error is not None:
msg += ' (autocorrect error={0})'.format(str(autocorrect_error))
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
else:
msg = 'Found infrastructure manifest [{0}]: this file is no longer supported by the Brent Resource Manager. Add this information to the Resource descriptor instead or enable the autocorrect option'.format(inf_manifest_path)
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
def __create_descriptor(self, journal, source_request, file_ops,
source_tree, descriptor):
file_ops.append(
handlers_api.CreateDirectoryOp(source_tree.lm_definitions_path,
handlers_api.EXISTING_IGNORE))
descriptor_content = descriptor_utils.DescriptorParser().write_to_str(
descriptor)
file_ops.append(
handlers_api.CreateFileOp(source_tree.descriptor_file_path,
descriptor_content,
handlers_api.EXISTING_IGNORE))
def validate_unsupported_lifecycle_manifest(self, journal, validation_options, errors, warnings, lifecycle_manifest_path, descriptor_path):
if os.path.exists(lifecycle_manifest_path) and os.path.exists(descriptor_path):
if validation_options.allow_autocorrect == True:
journal.event('Found unsupported lifecycle manifest [{0}], attempting to autocorrect by moving contents to Resource descriptor'.format(lifecycle_manifest_path))
managed_to_autocorrect = False
autocorrect_error = None
try:
with open(lifecycle_manifest_path, 'r') as f:
lifecycle_manifest_content = yaml.safe_load(f.read())
descriptor = descriptor_utils.DescriptorParser().read_from_file(descriptor_path)
if 'types' in lifecycle_manifest_content:
for entry in lifecycle_manifest_content['types']:
if 'lifecycle_type' in entry and 'infrastructure_type' in entry:
lifecycle_type = entry['lifecycle_type']
infrastructure_type = entry['infrastructure_type']
if lifecycle_type in descriptor.default_driver:
if 'selector' not in descriptor.default_driver[lifecycle_type]:
descriptor.default_driver[lifecycle_type]['selector'] = {}
if 'infrastructure-type' not in descriptor.default_driver[lifecycle_type]['selector']:
descriptor.default_driver[lifecycle_type]['selector']['infrastructure-type'] = []
descriptor.default_driver[lifecycle_type]['selector']['infrastructure-type'].append(infrastructure_type)
else:
descriptor.insert_default_driver(lifecycle_type, [infrastructure_type])
descriptor_utils.DescriptorParser().write_to_file(descriptor, descriptor_path)
os.rename(lifecycle_manifest_path, lifecycle_manifest_path + '.bak')
managed_to_autocorrect = True
except Exception as e:
autocorrect_error = e
if not managed_to_autocorrect:
msg = 'Found lifecycle manifest [{0}]: this file is no longer supported by the Brent Resource Manager. Unable to autocorrect this issue, please add this information to the Resource descriptor manually instead'.format(lifecycle_manifest_path)
if autocorrect_error is not None:
msg += ' (autocorrect error={0})'.format(str(autocorrect_error))
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
else:
msg = 'Found lifecycle manifest [{0}]: this file is no longer supported by the Brent Resource Manager. Add this information to the Resource descriptor instead or enable the autocorrect option'.format(lifecycle_manifest_path)
journal.error_event(msg)
errors.append(project_validation.ValidationViolation(msg))
return
def execute(self):
self.journal.event('Pushing ETSI Package Content')
lm_session = self.env_sessions.lm
pkg_driver = lm_session.pkg_mgmt_driver
if (self.pkg_meta.is_etsi_ns_content()):
# Need to get the descriptor to determin the full ID (descriptor_name) as namein the pkg_meta is not full
descriptor_path = etsi_ns_handler_api.EtsiNsPkgContentTree(
self.push_workspace).descriptor_definitions_file_path
descriptor, descriptor_yml_str = descriptors.DescriptorParser(
).read_from_file_with_raw(descriptor_path)
descriptor_name = descriptor.get_name()
self.journal.event(
'Removing any existing ETSI_NS assembly package named {0} (version: {1}) from TNC-O: {2} ({3})'
.format(descriptor_name, self.pkg_meta.version,
lm_session.env.name, lm_session.env.address))
try:
pkg_driver.delete_nsd_package(descriptor_name)
except lm_drivers.NotFoundException:
self.journal.event(
'No package named {0} found'.format(descriptor_name))
pkg_driver.onboard_nsd_package(descriptor_name, self.pkg.path)
elif (self.pkg_meta.is_etsi_vnf_content()):
descriptor_path = etsi_vnf_handler_api.EtsiVnfPkgContentTree(
self.push_workspace).definitions_descriptor_file_path
descriptor, descriptor_yml_str = descriptors.DescriptorParser(
).read_from_file_with_raw(descriptor_path)
descriptor_name = descriptor.get_name()
self.journal.event(
'Removing any existing ETSI_NS assembly package named {0} (version: {1}) from TNC-O: {2} ({3})'
.format(descriptor_name, self.pkg_meta.version,
lm_session.env.name, lm_session.env.address))
try:
pkg_driver.delete_package(descriptor_name)
except lm_drivers.NotFoundException:
self.journal.event(
'No package named {0} found'.format(descriptor_name))
pkg_driver.onboard_package(descriptor_name, self.pkg.path)
else:
raise EtsiPushProcessError('Not an ETSI package, Not pushing.')
def __clear_existing_descriptor(self, journal, env_sessions):
lm_session = env_sessions.lm
descriptor_path = self.tree.root_descriptor_file_path
descriptor = descriptor_utils.DescriptorParser().read_from_file(descriptor_path)
descriptor_name = descriptor.get_name()
descriptor_version = descriptor.get_version()
journal.event('Removing descriptor {0} from LM ({1})'.format(descriptor_name, lm_session.env.address))
descriptor_driver = lm_session.descriptor_driver
try:
descriptor_driver.delete_descriptor(descriptor_name)
env_sessions.mark_lm_updated()
except lm_drivers.NotFoundException:
journal.event('Descriptor {0} not found'.format(descriptor_name))
return descriptor_name, descriptor_version
def __determine_project_id(self):
descriptor_path = self.tree.descriptor_file_path
descriptor = descriptors.DescriptorParser().read_from_file(
descriptor_path)
descriptor_name = descriptor.get_name()
return descriptor_name
