def _update_collector(self, collector, collector_obj):
plugin_info = collector['plugin_info']
if 'secret' in plugin_info:
plugin_info['secret_id'] = self.secret_name2id[
plugin_info['secret']]
del plugin_info['secret']
if 'secret_group' in plugin_info:
plugin_info['secret_group_id'] = self.secret_group_name2id[
plugin_info['secret_group']]
del plugin_info['secret_group']
params = {
'name': collector['name'],
'plugin_info': plugin_info,
'priority': collector.get('priority', 1),
'domain_id': collector_obj.domain_id,
'collector_id': collector_obj.collector_id,
'tags': collector.get('tags', {})
}
collector_obj = self.inventory.Collector.update(
params, metadata=self.get_meta())
print("########### Update Collector ###############")
print_json(collector_obj)
self.regist_collectors.append(collector_obj)
return collector_obj
def _find_domain(self, domain_info):
param = {
'query': {
'filter': [{
'k': 'state',
'v': 'ENABLED',
'o': 'eq'
}]
}
}
domain_id = domain_info.get('domain_id', None)
domain_name = domain_info.get('name', None)
if domain_id:
param['domain_id'] = domain_id
elif domain_name:
param['name'] = domain_name
else:
print(
f'############ CANNOT FIND DOMAIN (domain_name: {domain_name}, domain_id: {domain_id}) ############'
)
return None
print(f'############ FIND DOMAIN ({param}) ############')
result = None
result = self.identity.Domain.list(param)
if len(result.results) == 1:
domain = result.results[0]
print_json(domain)
print(f'############ FOUND - DOMAIN ({domain}) ############')
return domain
print(f'############ DOMAIN NOT FOUND ############')
return None
def _find_and_update_project(self, project_param, domain):
print("########### FIND Project ###############")
query = {
'filter': [{
'k': 'name',
'v': project_param['name'],
'o': 'eq'
}]
}
projects = self.identity.Project.list(
{
'query': query,
'domain_id': domain.domain_id
},
metadata=self.get_meta())
if len(projects.results) == 0:
print("########### NOT FOUND - project ###############")
return None
if len(projects.results) > 1:
print(
"########### Multiple projecs found - use one ###############")
if len(projects.results) == 1:
print("########### FOUND - project ###############")
prj = projects.results[0]
print_json(prj)
project_param['project_id'] = prj.project_id
project_param.update({'domain_id': domain.domain_id})
prj = self.identity.Project.update(project_param,
metadata=self.get_meta())
print("########### UDATE PROJECT ###############")
return prj.project_id
def _find_project_group(self, project_group, domain):
pg_name = project_group.get('name')
if pg_name is None:
print('##### CANNOT FIND PROJECT GROUP #####')
return None
query = {'filter': [{'k': 'name', 'v': pg_name, 'o': 'eq'}]}
results = self.identity.ProjectGroup.list(
{
'query': query,
'domain_id': domain.domain_id
},
metadata=self.get_meta())
if len(results.results) == 1:
# found
pg = results.results[0]
print('##### FOUDND PROJECT GROUP #####')
print_json(pg)
return pg.project_group_id
if len(results.results) > 1:
# Too many matched. Use one.
print(
'##### FOUDND MULTIPLE PROJECT GROUP - Use the first one.#####'
)
pg = results.results[0]
print_json(pg)
return pg.project_group_id
else:
print('##### PROJECT GROUP - NOT FOUDND #####')
return None
def register_local_repository(self, param):
if param:
repo = self.repository.Repository.register(param, metadata=self.get_meta())
self.append_terminator(self.repository.Repository.deregister, {'repository_id': repo.repository_id})
print_json(repo)
return repo
return None
def _create_secret_group(self, name, secret_name_list, domain):
default_param = {'name': name, 'domain_id': domain.domain_id}
# Create Secret Group
secret_group_obj = self.secret.SecretGroup.create(
default_param, metadata=self.get_meta())
sec_id_list = []
for name in secret_name_list:
sec_id = self.secret_name2id[name]
sec_id_list.append(sec_id)
for sec_id in sec_id_list:
sec_param = {
'secret_id': sec_id,
'secret_group_id': secret_group_obj.secret_group_id,
'domain_id': domain.domain_id
}
self.secret.SecretGroup.add_secret(sec_param,
metadata=self.get_meta())
self.secret_group_name2id[
secret_group_obj.name] = secret_group_obj.secret_group_id
self.append_terminator(
self.secret.SecretGroup.delete, {
'domain_id': domain.domain_id,
'secret_group_id': secret_group_obj.secret_group_id
})
print("########### Create SECRET GROUP ###############")
print_json(secret_group_obj)
def collect(self, domain):
for collect in self.regist_collectors:
collector_id = collect.collector_id
params2 = {
'collector_id': collector_id,
'collect_mode': 'ALL',
'domain_id': domain.domain_id
}
job = self.inventory.Collector.collect(params2,
metadata=self.get_meta())
print("########### Do Collect!! ###############")
print_json(job)
def _create_user(self, user_data, domain_id):
print("########### Create User ###############")
user_data.update({'domain_id': domain_id})
#print(f"meta: {self.get_meta()}")
print(f"user_data: {user_data}")
user = self.identity.User.create(user_data, metadata=self.get_meta())
self.append_terminator(self.identity.User.delete, {
'domain_id': domain_id,
'user_id': user.user_id
})
print_json(user)
return user
def _add_schedule(self, schedule, domain):
schedule['domain_id'] = domain.domain_id
schedule_obj = self.statistics.Schedule.add(schedule,
metadata=self.get_meta())
self.schedule_name2id[schedule_obj.topic] = schedule_obj.schedule_id
self.append_terminator(self.statistics.Schedule.delete, {
'schedule_id': schedule_obj.schedule_id,
'domain_id': domain.domain_id
})
print("########### add schedule #############")
print_json(schedule_obj)
return schedule_obj
def _update_user(self, user_data, domain_id):
user = None
try:
# update_user
user_data.update({'domain_id': domain_id})
user = self.identity.User.update(user_data,
metadata=self.get_meta())
print("########### Update User - update-mode ###############")
print_json(user)
except Exception as e:
print(f'Cannot update user. (user={user}')
return user
def _update_region(self, region_param, region_obj):
region_default_params = {
'name': region_param['name'],
'region_id': region_obj.region_id,
'domain_id': region_obj.domain_id
}
region_default_params.update(region_param)
region_obj = self.inventory.Region.update(region_default_params,
metadata=self.get_meta())
print("########### Update Region ###############")
print_json(region_obj)
return region_obj
def _create_project_group(self, project_group, domain):
pg_name = project_group.get('name', random_string()[0:10])
param = {'name': pg_name, 'domain_id': domain.domain_id}
# Overwrite param, if needed
param.update(project_group)
pg = self.identity.ProjectGroup.create(param, metadata=self.get_meta())
print("########### Create Project-Group ###############")
print_json(pg)
self.append_terminator(self.identity.ProjectGroup.delete, {
'project_group_id': pg.project_group_id,
'domain_id': domain.domain_id
})
return pg.project_group_id
def _register_datasource(self, param, domain):
param['domain_id'] = domain.domain_id
ds_obj = self.monitoring.DataSource.register(param, metadata=self.get_meta())
self.datasource_name2id[ds_obj.name] = ds_obj.data_source_id
self.append_terminator(
self.monitoring.DataSource.deregister,
{
'data_source_id': ds_obj.data_source_id,
'domain_id': domain.domain_id
}
)
print("########### Create DataSource #############")
print_json(ds_obj)
return ds_obj
def _create_project(self, param2, domain):
print("########### Create Project ###############")
name = random_string()[0:10]
param = {'name': name, 'domain_id': domain.domain_id}
# Overwrite param, if needed
param.update(param2)
project = self.identity.Project.create(param, metadata=self.get_meta())
print_json(project)
self.append_terminator(self.identity.Project.delete, {
'project_id': project.project_id,
'domain_id': domain.domain_id
})
return project.project_id
def _create_collector(self, collector, domain):
plugin_info = collector['plugin_info']
print("XXXXXXXXXXXXXXXXXXXX secret name 2 id XXXXXXXXXXXXXXXXX")
print(self.secret_name2id)
# is_public
is_public = collector.get('is_public', True)
# secret
secret = plugin_info.get('secret', None)
if secret:
plugin_info['secret_id'] = self.secret_name2id[secret]
del plugin_info['secret']
# secret Group
secret_group = plugin_info.get('secret_group', None)
if secret_group:
plugin_info['secret_group_id'] = self.secret_group_name2id[
secret_group]
del plugin_info['secret_group']
params = {
'name': collector['name'],
'is_public': is_public,
'plugin_info': plugin_info,
'priority': collector.get('priority', 1),
'domain_id': domain.domain_id,
'tags': collector.get('tags', {})
}
# project_id
project_name = collector.get('project_name', None)
if project_name:
# Map to project_name to project_id
project_id = self.project_name2id[project_name]
params.update({'project_id': project_id})
print(params)
collector_obj = self.inventory.Collector.create(
params, metadata=self.get_meta())
print("########### Create Collector ###############")
print_json(collector_obj)
self.regist_collectors.append(collector_obj)
self.append_terminator(
self.inventory.Collector.delete, {
'domain_id': domain.domain_id,
'collector_id': collector_obj.collector_id
})
def _create_region(self, region, domain):
region_default_params = {
'name': region.get('name', f'region-{random_string()[0:4]}'),
'domain_id': domain.domain_id
}
region_default_params.update(region)
region_obj = self.inventory.Region.create(region_default_params,
metadata=self.get_meta())
print("########### Create Region ###############")
print_json(region_obj)
self.region_name2id[region_obj.name] = region_obj.region_id
self.append_terminator(self.inventory.Region.delete, {
'domain_id': domain.domain_id,
'region_id': region_obj.region_id
})
return region_obj
def _update_zone(self, zone, zone_obj):
region_name = zone['region']
if self.zone_name2id.get(region_name) is None:
self.zone_name2id[region_name] = {}
# region_id = self.region_name2id[region_name]
zone_default_params = {
'name': zone.get('name', f'zone-{random_string()[0:4]}'),
'zone_id': zone_obj.zone_id,
'domain_id': zone_obj.domain_id
}
zone_default_params.update(zone)
del zone_default_params['region']
zone_obj = self.inventory.Zone.update(zone_default_params,
metadata=self.get_meta())
print("########### Update Zone ###############")
print_json(zone_obj)
return zone_obj
def create_user_api_keys(self, api_key_users, domain):
result = {}
for api_key_user in api_key_users:
api_default_param = {
'user_id': api_key_user['user_id'],
'domain_id': domain.domain_id
}
api_key_obj = self.identity.APIKey.create(
api_default_param,
metadata=self.get_meta()
)
result[api_key_user['user_id']] = api_key_obj.api_key
print("########### Create a new user API KEY ###############")
print_json(api_key_obj)
self.append_terminator(
self.identity.APIKey.delete,
{'domain_id': domain.domain_id, 'api_key_id': api_key_obj.api_key_id}
)
return result
def _update_pool(self, pool, pool_obj):
region_name = pool['region']
# region_id = self.region_name2id[region_name]
zone_name = pool['zone']
zone_id = self.zone_name2id[region_name][zone_name]
default_pool_params = {
'name': pool['name'],
'pool_id': pool_obj.pool_id,
'domain_id': pool_obj.domain_id
}
default_pool_params.update(pool)
del default_pool_params['region']
del default_pool_params['zone']
pool_obj = self.inventory.Pool.update(default_pool_params,
metadata=self.get_meta())
print("########### Update Pool ###############")
print_json(pool_obj)
return pool_obj
def _create_secret(self, secret, domain):
data = secret['data']
default_param = secret
# Project
project_name = secret.get('project_name', None)
if project_name:
project_id = self.project_name2id[project_name]
default_param['project_id'] = project_id
del default_param['project_name']
# ServiceAccount
service_account_name = secret.get('service_account', None)
if service_account_name:
service_account_id = self.service_account_name2id[service_account_name]
default_param['service_account_id'] = service_account_id
del default_param['service_account']
default_param.update({
'domain_id': domain.domain_id
})
print(f"Create Secret: {default_param}")
secret_obj = self.secret.Secret.create(default_param, metadata=self.get_meta())
self.secret_name2id[secret_obj.name] = secret_obj.secret_id
self.append_terminator(
self.secret.Secret.delete,
{
'domain_id': domain.domain_id,
'secret_id': secret_obj.secret_id
}
)
print("########### Create SECRET ###############")
print_json(secret_obj)
issue = self.secret.Secret.get_data(
{'secret_id': secret_obj.secret_id, 'domain_id': domain.domain_id},
metadata=self.get_meta()
)
print("######### ISSUE SECRET #########")
print_json(issue)
def _create_pool(self, pool, domain):
region_name = pool['region']
# region_id = self.region_name2id[region_name]
zone_name = pool['zone']
zone_id = self.zone_name2id[region_name][zone_name]
default_pool_params = {
'name': pool['name'],
'zone_id': zone_id,
'domain_id': domain.domain_id
}
del pool['region']
del pool['zone']
default_pool_params.update(pool)
pool_obj = self.inventory.Pool.create(default_pool_params,
metadata=self.get_meta())
print("########### Create Pool ###############")
print_json(pool_obj)
self.append_terminator(self.inventory.Pool.delete, {
'domain_id': domain.domain_id,
'pool_id': pool_obj.pool_id
})
return pool_obj
def _find_and_update_service_account(self, service_account_param, domain):
print("########### FIND ServiceAccount ###############")
query = {
'filter': [{
'k': 'name',
'v': service_account_param['name'],
'o': 'eq'
}]
}
service_accounts = self.identity.ServiceAccount.list(
{
'query': query,
'domain_id': domain.domain_id
},
metadata=self.get_meta())
if len(service_accounts.results) == 0:
print("########### NOT FOUND - service accounts ###############")
return None
if len(service_accounts.results) > 1:
print(
"########### Multiple service accounts found - use one ###############"
)
if len(service_accounts.results) == 1:
print("########### FOUND - ServiceAccount ###############")
service_account = service_accounts.results[0]
print_json(service_account)
service_account_param[
'service_account_id'] = service_account.service_account_id
service_account_param.update({'domain_id': domain.domain_id})
# provider can not be updated
if 'provider' in service_account_param:
del service_account_param['provider']
service_account = self.identity.ServiceAccount.update(
service_account_param, metadata=self.get_meta())
print("########### UDATE ServiceAccount ###############")
return service_account.service_account_id
def _create_zone(self, zone, domain):
region_name = zone['region']
if self.zone_name2id.get(region_name) is None:
self.zone_name2id[region_name] = {}
region_id = self.region_name2id[region_name]
zone_default_params = {
'name': zone.get('name', f'zone-{random_string()[0:4]}'),
'region_id': region_id,
'domain_id': domain.domain_id
}
# del zone['region']
zone_default_params.update(zone)
del zone_default_params['region']
zone_obj = self.inventory.Zone.create(zone_default_params,
metadata=self.get_meta())
print("########### Create Zone ###############")
print_json(zone_obj)
self.append_terminator(self.inventory.Zone.delete, {
'domain_id': domain.domain_id,
'zone_id': zone_obj.zone_id
})
return zone_obj
def _create_service_account(self, param2, domain):
print("########### Create Service Account ###############")
name = random_string()[0:10]
param = {'name': name, 'domain_id': domain.domain_id}
# Overwrite param, if needed
param.update(param2)
# project_id
project_name = param.get('project_name', None)
if project_name:
project_id = self.project_name2id[project_name]
param['project_id'] = project_id
del param['project_name']
service_account = self.identity.ServiceAccount.create(
param, metadata=self.get_meta())
print_json(service_account)
self.append_terminator(
self.identity.ServiceAccount.delete, {
'service_account_id': service_account.service_account_id,
'domain_id': domain.domain_id
})
return service_account.service_account_id
def _create_domain(self,
param2={},
domainOwner={
'owner_id': 'admin',
'password': '******'
}):
""" Create Domain
1) Create Domain
2) Create Domain Owner
3) Create Token
Args: json data
param = {
'name': 'root',
'config': {
'aaa': 'bbbb'
},
}
}
"""
param = {
'name': random_string(),
'tags': {
'company': 'MEGAZONE CLOUD'
},
'config': {
'icon':
'https://assets-console-spaceone-stg.s3.ap-northeast-2.amazonaws.com/mzc.jpg'
}
}
param.update(param2)
print("########## Create Domain ################")
domain = self.identity.Domain.create(param)
print_json(domain)
self.append_terminator(self.identity.Domain.delete,
{'domain_id': domain.domain_id})
if param2.get('plugin_info'):
print("########## Update Domain Plugin ##########")
update_param = {
'domain_id': domain.domain_id,
'plugin_info': param2.get('plugin_info')
}
print(update_param)
domain = self.identity.Domain.update(update_param)
print_json(domain)
print("########## Create Domain Owner ##########")
owner_id = domainOwner['owner_id']
owner_pw = domainOwner['password']
param = {
'owner_id': owner_id,
'password': owner_pw,
'name': 'Domain Admin',
'timezone': 'utc+9',
'email': 'admin' + random_string()[0:5] + '@mz.co.kr',
'mobile': '+821012341234',
'domain_id': domain.domain_id
}
param.update(domainOwner)
# Create Domain Owner
owner = self.identity.DomainOwner.create(param)
print("########## Create Domain Owner ###############")
print_json(owner)
self.append_terminator(self.identity.DomainOwner.delete, {
'domain_id': domain.domain_id,
'owner_id': owner.owner_id
})
# Create Token
token = self._get_domain_owner_token(domain, owner_id, owner_pw)
return domain, token
def register_remote_repositories(self, remote_repos, domain):
for remote_repo in remote_repos:
remote_repo['domain_id'] = domain.domain_id
repo = self._register_remote_repository(remote_repo, domain)
print_json(repo)
def _list_provider(self, domain):
params = {'domain_id': domain.domain_id}
print("######### List Provider ###########")
providers = self.identity.Provider.list(params,
metadata=self.get_meta())
print_json(providers)
