def update(self, params):
"""Update Plugin. (local repo only)
Args:
params (dict): {
'plugin_id': 'str',
'name': 'str',
'capability': 'dict',
'template': 'dict',
'labels': 'list',
'tags': 'dict'
'domain_id': 'str'
}
Returns:
plugin_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
# Pre-condition Check
self._check_template(params.get('template'))
# self._check_capability(params.get('capability'))
self._check_service_type(params.get('service_type'))
plugin_mgr: LocalPluginManager = self.locator.get_manager(
'LocalPluginManager')
return plugin_mgr.update_plugin(params)
def register(self, params):
"""Register data source
Args:
params (dict): {
'name': 'str',
'billing_type': 'str',
'plugin_info': 'dict',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
data_source_vo (object)
"""
domain_id = params['domain_id']
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
self._check_plugin_info(params['plugin_info'])
plugin_info = self._get_plugin(params['plugin_info'], domain_id)
params['provider'] = plugin_info.get('provider')
# Update metadata
endpoint, updated_version = self.plugin_mgr.get_billing_plugin_endpoint(
params['plugin_info'], domain_id)
if updated_version:
params['plugin_info']['version'] = updated_version
options = params['plugin_info'].get('options', {})
plugin_metadata = self._init_plugin(endpoint, options)
params['plugin_info']['metadata'] = plugin_metadata
return self.data_source_mgr.register_data_source(params)
def update(self, params):
""" Update user
Args:
params (dict): {
'user_id': 'str',
'password': '******',
'name': 'str',
'email': 'str',
'language': 'str',
'timezone': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
user_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'timezone' in params:
self._check_timezone(params['timezone'])
return self.user_mgr.update_user(params)
def create(self, params):
"""
Args:
params (dict): {
'name': 'str',
'region_code': 'str',
'provider': 'str',
'tags': 'list',
'domain_id': 'str'
}
Returns:
region_vo (object)
"""
params['provider'] = params.get('provider', 'datacenter')
params[
'ref_region'] = f'{params["domain_id"]}.{params["provider"]}.{params["region_code"]}'
# Temporary Code for Tag Migration
if 'tags' in params:
if isinstance(params['tags'], dict):
params['tags'] = utils.dict_to_tags(params['tags'])
region_mgr: RegionManager = self.locator.get_manager('RegionManager')
return region_mgr.create_region(params)
def create(self, params):
""" Create domain
Args:
params (dict): {
'name': 'str',
'config': 'dict',
'plugin_info': 'dict',
'tags': 'dict'
}
Returns:
domain_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
# Create Domain
domain_vo: Domain = self.domain_mgr.create_domain(params)
# Create domain secret
domain_secret_mgr: DomainSecretManager = self._get_domain_secret_manager(
)
domain_secret_mgr.create_domain_secret(domain_vo.domain_id)
return domain_vo
def update(self, params):
"""
Args:
params (dict): {
'region_id': 'str',
'name': 'str',
'tags': 'list',
'domain_id': 'str'
}
Returns:
region_vo (object)
"""
params['updated_by'] = self.transaction.get_meta('collector_id') or 'manual'
region_vo = self.region_mgr.get_region(params['region_id'], params['domain_id'])
# Temporary Code for Tag Migration
if 'tags' in params:
if isinstance(params['tags'], dict):
params['tags'] = utils.dict_to_tags(params['tags'])
if not region_vo.region_key:
params['region_key'] = f'{region_vo.provider}.{region_vo.region_code}'
return self.region_mgr.update_region_by_vo(params, region_vo)
def modify_member(self, params):
""" Modify project member
Args:
params (dict): {
'project_id': 'str',
'user_id': 'str',
'labels': 'list',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
role_binding_vo (object)
"""
project_id = params['project_id']
user_id = params['user_id']
domain_id = params['domain_id']
project_vo = self.project_mgr.get_project(project_id, domain_id)
role_binding_mgr: RoleBindingManager = self.locator.get_manager(
'RoleBindingManager')
role_binding_vos = role_binding_mgr.get_project_role_binding(
'identity.User', user_id, domain_id, project_vo=project_vo)
if role_binding_vos.count() == 0:
raise ERROR_NOT_FOUND(key='user_id', value=user_id)
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return role_binding_mgr.update_role_binding_by_vo(
params, role_binding_vos[0])
def create(self, params):
""" Create project
Args:
params (dict): {
'name': 'str',
'project_group_id': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
project_vo (object)
"""
params['created_by'] = self.transaction.get_meta('user_id')
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'project_group_id' in params:
project_group_mgr: ProjectGroupManager = self.locator.get_manager(
'ProjectGroupManager')
params['project_group'] = project_group_mgr.get_project_group(
params['project_group_id'], params['domain_id'])
return self.project_mgr.create_project(params)
def add_member(self, params):
""" Add project group member
Args:
params (dict): {
'project_group_id': 'str',
'user_id': 'str',
'role_id': 'str',
'labels': 'list',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
role_binding_vo (object)
"""
params['resource_type'] = 'identity.User'
params['resource_id'] = params['user_id']
del params['user_id']
role_mgr: RoleManager = self.locator.get_manager('RoleManager')
role_binding_mgr: RoleBindingManager = self.locator.get_manager(
'RoleBindingManager')
role_vo = role_mgr.get_role(params['role_id'], params['domain_id'])
if role_vo.role_type != 'PROJECT':
raise ERROR_ONLY_PROJECT_ROLE_TYPE_ALLOWED()
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return role_binding_mgr.create_role_binding(params)
def update(self, params):
params = copy.deepcopy(params)
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return UserConfigFactory(**params)
def get_managed_policy(self, policy_id, domain_id):
repo_managed_policy_info = self._get_managed_policy_from_repository(
policy_id, domain_id)
local_managed_policy_vo = self._get_managed_policy_from_local(
policy_id, domain_id)
if repo_managed_policy_info:
if local_managed_policy_vo:
if repo_managed_policy_info.get(
'updated_at') == local_managed_policy_vo.updated_at:
return local_managed_policy_vo
return self._update_managed_policy(local_managed_policy_vo,
repo_managed_policy_info)
if 'tags' in repo_managed_policy_info:
repo_managed_policy_info['tags'] = utils.dict_to_tags(
repo_managed_policy_info['tags'])
return self._create_managed_policy(policy_id, domain_id,
repo_managed_policy_info)
else:
if local_managed_policy_vo:
return local_managed_policy_vo
raise ERROR_NOT_FOUND(key='policy_id', value=policy_id)
def create(self, params):
""" Create project group
Args:
params (dict): {
'name': 'str',
'parent_project_group_id': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
project_group_vo (object)
"""
params['created_by'] = self.transaction.get_meta('user_id')
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'parent_project_group_id' in params:
params['parent_project_group'] = self._get_parent_project_group(
params['parent_project_group_id'], params['domain_id'])
else:
params['parent_project_group'] = None
return self.project_group_mgr.create_project_group(params)
def create(self, params):
"""
Args:
params (dict): {
'name': 'str',
'data': 'dict',
'provider': 'str',
'project_id': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
service_account_vo (object)
"""
self._check_data(params['data'], params['provider'])
if 'project_id' in params:
params['project'] = self._get_project(params['project_id'],
params['domain_id'])
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return self.service_account_mgr.create_service_account(params)
def update(self, params):
"""Update Schema. (local repo only)
Args:
params (dict): {
'name': 'str',
'schema': 'dict',
'labels': 'list',
'tags': 'dict'
'domain_id': 'str'
}
Returns:
schema_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
# Pre-condition Check
self._check_schema(params.get('schema'))
self._check_service_type(params.get('service_type'))
schema_mgr: LocalSchemaManager = self.locator.get_manager(
'LocalSchemaManager')
return schema_mgr.update_schema(params)
def add(self, params):
"""Add schedule for statistics
Args:
params (dict): {
'topic': 'str',
'options': 'dict',
'schedule': 'dict',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
schedule_vo
"""
domain_id = params['domain_id']
options = copy.deepcopy(params['options'])
schedule = params['schedule']
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
self._check_schedule(schedule)
self._verify_query_option(options, domain_id)
return self.schedule_mgr.add_schedule(params)
def create(self, params):
"""Create Policy (local repo only)
Args:
params (dict): {
'name': 'str',
'permissions': 'list',
'labels': 'list',
'tags': 'dict',
'project_id': 'str',
'domain_id': 'str'
}
Returns:
policy_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
self._check_project(params.get('project_id'), params['domain_id'])
policy_mgr: LocalPolicyManager = self.locator.get_manager(
'LocalPolicyManager')
# Only LOCAL repository can be created
repo_mgr: RepositoryManager = self.locator.get_manager(
'RepositoryManager')
params['repository'] = repo_mgr.get_local_repository()
params['repository_id'] = params['repository'].repository_id
return policy_mgr.create_policy(params)
def update(self, params):
""" Update project
Args:
params (dict): {
'project_id': 'str',
'name': 'str',
'project_group_id': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
project_vo (object)
"""
domain_id = params['domain_id']
project_vo = self.project_mgr.get_project(params['project_id'],
domain_id)
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'project_group_id' in params:
project_group_mgr: ProjectGroupManager = self.locator.get_manager(
'ProjectGroupManager')
params['project_group'] = project_group_mgr.get_project_group(
params['project_group_id'], domain_id)
return self.project_mgr.update_project_by_vo(params, project_vo)
def create(self, params):
"""
Args:
params (dict): {
'name': 'str',
'cloud_service_type': 'str',
'cloud_service_group': 'str',
'provider': 'str',
'data': 'dict',
'metadata': 'dict',
'reference': 'dict',
'tags': 'list or dict',
'region_code': 'str',
'project_id': 'str',
'domain_id': 'str'
}
Returns:
cloud_service_vo (object)
"""
data_mgr: CollectionDataManager = self.locator.get_manager(
'CollectionDataManager')
domain_id = params['domain_id']
provider = params.get('provider',
self.transaction.get_meta('secret.provider'))
project_id = params.get('project_id')
secret_project_id = self.transaction.get_meta('secret.project_id')
region_code = params.get('region_code')
# Temporary Code for Tag Migration
if 'tags' in params:
if isinstance(params['tags'], dict):
params['tags'] = utils.dict_to_tags(params['tags'])
if provider:
params['provider'] = provider
if project_id:
self.identity_mgr.get_project(project_id, domain_id)
elif secret_project_id:
params['project_id'] = secret_project_id
if region_code:
params[
'ref_region'] = f'{domain_id}.{provider or "datacenter"}.{region_code}'
params['ref_cloud_service_type'] = f'{params["domain_id"]}.' \
f'{params["provider"]}.' \
f'{params["cloud_service_group"]}.' \
f'{params["cloud_service_type"]}'
params = data_mgr.create_new_history(
params,
exclude_keys=['domain_id', 'ref_region', 'ref_cloud_service_type'])
return self.cloud_svc_mgr.create_cloud_service(params)
def publish(self, params):
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
_LOGGER.debug(f'[publish] params: {params}')
plugin_mgr: PluginManager = self.locator.get_manager('PluginManager')
domain_id = params['domain_id']
try:
# unique: hostname + name
supervisor = self._supervisor_mgr.get_by_hostname(
params['hostname'], domain_id)
except ERROR_NOT_FOUND:
# create new supervisor
supervisor = self._supervisor_mgr.create(params)
###############################
# East EGG for Automatic Test
###############################
if params['name'] == 'root':
self._supervisor_mgr.update({
'supervisor_id': supervisor.supervisor_id,
'is_public': True,
'domain_id': domain_id
})
if supervisor:
plugins_info = params.get('plugin_info', [])
print(f'[publish] plugin_info: {plugins_info}')
for plugin in plugins_info:
# Update State (XXXX -> ACTIVE)
# Update endpoint (grpc://xxxx)
# There may be no plugin at DB (maybe deleted, or supervisor's garbage)
# self._plugin_mgr.update_plugin(plugin)
_LOGGER.debug(f'[publish] plugin={plugin}')
try:
plugin_mgr.update_plugin_state(plugin['plugin_id'],
plugin['version'],
plugin['state'],
plugin['endpoint'],
supervisor.supervisor_id)
except Exception as e:
_LOGGER.error(f'[publish] e={e}')
_LOGGER.warning(
f'[publish] Failed update plugin.state:{plugin["state"]}'
)
# Update endpoints, if needed
if 'endpoints' in plugin:
_LOGGER.debug(
f'[publish] endpoints: {plugin["endpoints"]}')
plugin_mgr.update_plugin_endpoints(
plugin['plugin_id'], plugin['version'],
supervisor.supervisor_id, plugin['endpoints'])
else:
# There is no plugin_info
supervisor = self._supervisor_mgr.create(params)
return supervisor
def update(self, params):
domain_id = params['domain_id']
_LOGGER.debug(f'[update] params: {params}')
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
# TODO: Should I validate supervisor_id?
return self._supervisor_mgr.update(params)
def register(self, params):
domain_id = params['domain_id']
_LOGGER.debug(f'[register] params: {params}')
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
# TODO: Should I validate supervisor_id?
return self._supervisor_mgr.register(params['supervisor_id'],
domain_id)
def update(self, params):
"""
Args:
params (dict): {
'service_account_id': 'str',
'name': 'str',
'data': 'dict',
'project_id': 'str',
'tags': 'dict',
'release_project': 'bool',
'domain_id': 'str'
}
Returns:
service_account_vo (object)
"""
service_account_id = params['service_account_id']
domain_id = params['domain_id']
project_id = params.get('project_id')
release_project = params.get('release_project')
service_account_vo = self.service_account_mgr.get_service_account(
service_account_id, domain_id)
if 'data' in params:
self._check_data(params['data'], service_account_vo.provider)
if release_project:
params['project'] = None
params['project_id'] = None
elif project_id:
params['project'] = self._get_project(params['project_id'],
params['domain_id'])
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
service_account_vo = self.service_account_mgr.update_service_account_by_vo(
params, service_account_vo)
if release_project:
self.service_account_mgr.release_secret_project(
service_account_id, domain_id)
elif project_id:
self.service_account_mgr.update_secret_project(
service_account_id, project_id, domain_id)
return service_account_vo
def update(self, params):
"""
Args:
params (dict): {
'collector_id': 'str',
'name': 'str',
'priority': 'int',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
collector_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
collector_mgr: CollectorManager = self.locator.get_manager(
'CollectorManager')
collector_id = params['collector_id']
domain_id = params['domain_id']
try:
collector_vo = collector_mgr.get_collector(collector_id, domain_id)
except Exception as e:
raise ERROR_NO_COLLECTOR(collector_id=collector_id,
domain_id=domain_id)
# If plugin_info exists, we need deep merge with previous information
# (merged_params, version_check) = self._get_merged_params(params, collector_vo.plugin_info)
# _LOGGER.debug(f'[update] params: {params}')
# _LOGGER.debug(f'[update] merged_params: {merged_params}')
if 'plugin_info' in params:
original_plugin_info = collector_vo.plugin_info.to_dict()
version = params['plugin_info'].get(
'version', original_plugin_info['version'])
options = params['plugin_info'].get(
'options', original_plugin_info['options'])
upgrade_mode = params['plugin_info'].get(
'upgrade_mode', original_plugin_info['upgrade_mode'])
collector_mgr.update_plugin(collector_id, domain_id, version,
options, upgrade_mode)
del params['plugin_info']
return collector_mgr.update_collector_by_vo(collector_vo, params)
def update(self, params):
"""
Args:
params (dict): {
'cloud_service_type_id': 'str',
'service_code': 'str',
'is_primary': 'bool',
'is_major': 'bool',
'resource_type': 'str',
'metadata': 'dict',
'labels': 'list',
'tags': 'list or dict',
'domain_id': 'str'
}
Returns:
cloud_service_type_vo (object)
"""
data_mgr: CollectionDataManager = self.locator.get_manager('CollectionDataManager')
provider = params.get('provider', self.transaction.get_meta('secret.provider'))
domain_id = params['domain_id']
cloud_svc_type_vo = self.cloud_svc_type_mgr.get_cloud_service_type(params['cloud_service_type_id'],
domain_id)
# Temporary Code for Tag Migration
if 'tags' in params:
if isinstance(params['tags'], dict):
params['tags'] = utils.dict_to_tags(params['tags'])
if provider:
params['provider'] = provider
# if not cloud_svc_type_vo.ref_cloud_service_type:
if True:
params['ref_cloud_service_type'] = f'{domain_id}.' \
f'{cloud_svc_type_vo.provider}.' \
f'{cloud_svc_type_vo.group}.' \
f'{cloud_svc_type_vo.name}'
exclude_keys = ['cloud_service_type_id', 'domain_id', 'ref_cloud_service_type']
params = data_mgr.merge_data_by_history(params, cloud_svc_type_vo.to_dict(), exclude_keys=exclude_keys)
return self.cloud_svc_type_mgr.update_cloud_service_type_by_vo(params, cloud_svc_type_vo)
def update(self, params):
""" Update domain
Args:
params (dict): {
'domain_id': 'str',
'config': 'dict',
'tags': 'dict'
}
Returns:
domain_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return self.domain_mgr.update_domain(params)
def create(self, params):
""" Create secret group
Args:
params (dict): {
'name': 'str',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
secret_group_vo
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return self.secret_group_mgr.create_secret_group(params)
def create(self, params):
""" Create secret
Args:
params (dict): {
'name': 'str',
'data': 'dict',
'secret_type': 'str',
'tags': 'dict',
'schema': 'str',
'encrypted': 'bool',
'encrypt_options': 'dict',
'service_account_id': 'str',
'project_id': 'str',
'domain_id': 'str
}
Returns:
secret_vo
"""
domain_id = params['domain_id']
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'service_account_id' in params:
service_account_info = self._get_service_account(
params['service_account_id'], domain_id)
params['provider'] = service_account_info.get('provider')
params['project_id'] = service_account_info.get(
'project_info', {}).get('project_id')
else:
if 'project_id' in params:
self._check_project(params['project_id'], domain_id)
secret_vo = self.secret_mgr.create_secret(params)
secret_conn_mgr: SecretConnectorManager = self.locator.get_manager(
'SecretConnectorManager')
secret_conn_mgr.create_secret(secret_vo.secret_id, params['data'])
return secret_vo
def update(self, params):
"""Update data source
Args:
params (dict): {
'data_source_id': 'str',
'name': 'dict',
'plugin_info': 'dict',
'tags': 'dict'
'domain_id': 'str'
}
Returns:
data_source_vo (object)
"""
data_source_id = params['data_source_id']
domain_id = params['domain_id']
data_source_vo = self.data_source_mgr.get_data_source(
data_source_id, domain_id)
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
if 'plugin_info' in params:
self._check_plugin_info(params['plugin_info'])
if params['plugin_info'][
'plugin_id'] != data_source_vo.plugin_info.plugin_id:
raise ERROR_NOT_ALLOWED_PLUGIN_ID(
old_plugin_id=data_source_vo.plugin_info.plugin_id,
new_plugin_id=params['plugin_info']['plugin_id'])
# Update metadata
endpoint, updated_version = self.plugin_mgr.get_billing_plugin_endpoint(
params['plugin_info'], domain_id)
if updated_version:
params['plugin_info']['version'] = updated_version
options = params['plugin_info'].get('options', {})
plugin_metadata = self._init_plugin(endpoint, options)
params['plugin_info']['metadata'] = plugin_metadata
return self.data_source_mgr.update_data_source_by_vo(
params, data_source_vo)
def update(self, params):
""" Update role binding
Args:
params (dict): {
'role_binding_id': 'str',
'labels': 'list',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
role_binding_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return self.role_binding_mgr.update_role_binding(params)
def update(self, params):
"""Update config map
Args:
params (dict): {
'name': 'str',
'data': 'dict',
'tags': 'dict',
'domain_id': 'str'
}
Returns:
user_config_vo (object)
"""
if 'tags' in params:
params['tags'] = utils.dict_to_tags(params['tags'])
return self.user_config_mgr.update_user_config(params)
