def test_create_domain_config(self, *args):
params = {
'name': 'inventory.server.metadata.view.table.layout',
'data': {
'key': 'value'
},
'schema': 'test_schema',
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': utils.generate_id('domain')
}
self.transaction.method = 'create'
domain_config_svc = DomainConfigService(transaction=self.transaction)
domain_config_vo = domain_config_svc.create(params.copy())
print_data(domain_config_vo.to_dict(), 'test_create_domain_config')
DomainConfigInfo(domain_config_vo)
self.assertIsInstance(domain_config_vo, DomainConfig)
self.assertEqual(params['name'], domain_config_vo.name)
self.assertEqual(params['data'], domain_config_vo.data)
self.assertEqual(params['schema'], domain_config_vo.schema)
self.assertEqual(params['tags'], utils.tags_to_dict(domain_config_vo.tags))
self.assertEqual(params['domain_id'], domain_config_vo.domain_id)
def CloudServiceInfo(cloud_svc_vo: CloudService, minimal=False):
info = {
'cloud_service_id': cloud_svc_vo.cloud_service_id,
'name': cloud_svc_vo.name,
'state': cloud_svc_vo.state,
'cloud_service_group': cloud_svc_vo.cloud_service_group,
'cloud_service_type': cloud_svc_vo.cloud_service_type,
'provider': cloud_svc_vo.provider,
'region_code': cloud_svc_vo.region_code,
'reference': cloud_service_pb2.CloudServiceReference(
**cloud_svc_vo.reference.to_dict()) if cloud_svc_vo.reference else None,
'project_id': cloud_svc_vo.project_id,
}
if not minimal:
info.update({
'account': cloud_svc_vo.account,
'instance_type': cloud_svc_vo.instance_type,
'instance_size': cloud_svc_vo.instance_size,
'data': change_struct_type(cloud_svc_vo.data),
'metadata': change_struct_type(cloud_svc_vo.metadata),
'tags': change_struct_type(utils.tags_to_dict(cloud_svc_vo.tags)),
'collection_info': CollectionInfo(cloud_svc_vo.collection_info.to_dict()),
'domain_id': cloud_svc_vo.domain_id,
'created_at': utils.datetime_to_iso8601(cloud_svc_vo.created_at),
'updated_at': utils.datetime_to_iso8601(cloud_svc_vo.updated_at),
'deleted_at': utils.datetime_to_iso8601(cloud_svc_vo.deleted_at),
'launched_at': utils.datetime_to_iso8601(cloud_svc_vo.launched_at),
})
return cloud_service_pb2.CloudServiceInfo(**info)
def test_create_service_account(self, *args):
params = {
'name': 'SpaceONE',
'provider': 'aws',
'data': {
'account_id': '000321654'
},
'tags': {
'tag_key': 'tag_value'
},
'domain_id': utils.generate_id('domain')
}
self.transaction.method = 'create'
service_account_svc = ServiceAccountService(
transaction=self.transaction)
service_account_vo = service_account_svc.create(params.copy())
print_data(service_account_vo.to_dict(), 'test_create_service_account')
ServiceAccountInfo(service_account_vo)
self.assertIsInstance(service_account_vo, ServiceAccount)
self.assertEqual(params['name'], service_account_vo.name)
self.assertEqual(params['provider'], service_account_vo.provider)
self.assertEqual(params['domain_id'], service_account_vo.domain_id)
self.assertEqual(params.get('data', {}), service_account_vo.data)
self.assertEqual(params.get('tags', {}),
utils.tags_to_dict(service_account_vo.tags))
def test_update_service_account(self, *args):
new_service_account_vo = ServiceAccountFactory(
domain_id=self.domain_id)
params = {
'service_account_id': new_service_account_vo.service_account_id,
'name': 'Update Account Name',
'data': {
'account_id': 'update-1234'
},
'tags': {
'tag_key': 'tag_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
service_account_svc = ServiceAccountService(
transaction=self.transaction)
service_account_vo = service_account_svc.update(params.copy())
print_data(service_account_vo.to_dict(), 'test_update_service_account')
ServiceAccountInfo(service_account_vo)
self.assertIsInstance(service_account_vo, ServiceAccount)
self.assertEqual(new_service_account_vo.service_account_id,
service_account_vo.service_account_id)
self.assertEqual(params['name'], service_account_vo.name)
self.assertEqual(params['data'], service_account_vo.data)
self.assertEqual(params['tags'],
utils.tags_to_dict(service_account_vo.tags))
def CollectorInfo(vo, minimal=False):
info = {
'collector_id': vo.collector_id,
'name': vo.name,
'state': vo.state,
'provider': vo.provider,
'capability': change_struct_type(vo.capability),
'plugin_info': PluginInfo(vo.plugin_info, minimal=minimal),
'is_public': vo.is_public,
'project_id': vo.project_id
}
if not minimal:
info.update({
'priority':
vo.priority,
'created_at':
utils.datetime_to_iso8601(vo.created_at),
'last_collected_at':
utils.datetime_to_iso8601(vo.last_collected_at),
'tags':
change_struct_type(utils.tags_to_dict(vo.tags)),
'domain_id':
vo.domain_id
})
return collector_pb2.CollectorInfo(**info)
def SecretInfo(secret_vo: Secret, minimal=False):
info = {
'secret_id': secret_vo.secret_id,
'name': secret_vo.name,
'secret_type': secret_vo.secret_type
}
if minimal is False:
info.update({
'tags':
change_struct_type(utils.tags_to_dict(secret_vo.tags)),
'schema':
secret_vo.schema,
'provider':
secret_vo.provider,
'service_account_id':
secret_vo.service_account_id,
'project_id':
secret_vo.project_id,
'domain_id':
secret_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(secret_vo.created_at)
})
if getattr(secret_vo, 'secret_groups', None) is not None:
secret_group_infos = list(
map(lambda secret_group: SecretGroupInfo(secret_group),
secret_vo.secret_groups))
info.update(
{'secret_groups': change_list_value_type(secret_group_infos)})
return secret_pb2.SecretInfo(**info)
def test_register_metric_data_source_with_provider(self, mock_plugin_init,
mock_list_secrets,
mock_get_plugin, *args):
plugin_id = utils.generate_id('plugin')
plugin_version = '1.0'
mock_plugin_init.return_value = {
'metadata': {
'supported_resource_type':
['inventory.Server', 'inventory.CloudService'],
'supported_stat': ['AVERAGE', 'MAX', 'MIN'],
'required_keys': ['reference.resource_id']
}
}
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret'),
'schema': 'aws_access_key'
}],
'total_count':
1
}
mock_get_plugin.return_value = {
'capability': {
'use_resource_secret': True,
'supported_schema': ['aws_access_key', 'aws_assume_role'],
'monitoring_type': 'METRIC'
},
'provider': 'aws'
}
params = {
'name': 'AWS CloudWatch',
'plugin_info': {
'plugin_id': plugin_id,
'version': plugin_version,
'options': {},
'provider': 'aws'
},
'tags': {
'tag_key': 'tag_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'register'
data_source_svc = DataSourceService(transaction=self.transaction)
data_source_vo = data_source_svc.register(params.copy())
print_data(data_source_vo.to_dict(),
'test_register_metric_data_source_with_provider')
DataSourceInfo(data_source_vo)
self.assertIsInstance(data_source_vo, DataSource)
self.assertEqual(params['name'], data_source_vo.name)
self.assertEqual(params['tags'],
utils.tags_to_dict(data_source_vo.tags))
self.assertEqual(params['domain_id'], data_source_vo.domain_id)
def ServerInfo(server_vo: Server, minimal=False):
info = {
'server_id': server_vo.server_id,
'name': server_vo.name,
'state': server_vo.state,
'primary_ip_address': server_vo.primary_ip_address,
'os_type': server_vo.os_type,
'provider': server_vo.provider,
'cloud_service_group': server_vo.cloud_service_group,
'cloud_service_type': server_vo.cloud_service_type,
'region_code': server_vo.region_code,
'reference': server_pb2.ServerReference(
**server_vo.reference.to_dict()) if server_vo.reference else None,
'project_id': server_vo.project_id,
}
if not minimal:
info.update({
'ip_addresses': server_vo.ip_addresses,
'account': server_vo.account,
'instance_type': server_vo.instance_type,
'data': change_struct_type(server_vo.data),
'metadata': change_struct_type(server_vo.metadata),
'nics': list(map(ServerNIC, server_vo.nics)),
'disks': list(map(ServerDisk, server_vo.disks)),
'tags': change_struct_type(utils.tags_to_dict(server_vo.tags)),
'collection_info': CollectionInfo(server_vo.collection_info.to_dict()),
'domain_id': server_vo.domain_id,
'created_at': utils.datetime_to_iso8601(server_vo.created_at),
'updated_at': utils.datetime_to_iso8601(server_vo.updated_at),
'deleted_at': utils.datetime_to_iso8601(server_vo.deleted_at),
'launched_at': utils.datetime_to_iso8601(server_vo.launched_at)
})
return server_pb2.ServerInfo(**info)
def test_update_provider(self, *args):
new_provider_vo = ProviderFactory(provider='aws')
params = {
'provider': new_provider_vo.provider,
'name': 'Update AWS',
'template': {},
'metadata': {},
'tags': {
'tag_key': 'tag_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
provider_svc = ProviderService(transaction=self.transaction)
provider_vo = provider_svc.update(params.copy())
print_data(provider_vo.to_dict(), 'test_update_provider')
ProviderInfo(provider_vo)
self.assertIsInstance(provider_vo, Provider)
self.assertEqual(new_provider_vo.provider, provider_vo.provider)
self.assertEqual(params['name'], provider_vo.name)
self.assertEqual(params['template'], provider_vo.template)
self.assertEqual(params['metadata'], provider_vo.metadata)
self.assertEqual(params['tags'], utils.tags_to_dict(provider_vo.tags))
def test_update_domain_config(self, *args):
new_domain_config_vo = DomainConfigFactory(domain_id=self.domain_id)
params = {
'name': new_domain_config_vo.name,
'data': {
'update_data_key': 'update_data_value'
},
'schema': 'update_schema',
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
domain_config_svc = DomainConfigService(transaction=self.transaction)
domain_config_vo = domain_config_svc.update(params.copy())
print_data(domain_config_vo.to_dict(), 'test_update_domain_config')
DomainConfigInfo(domain_config_vo)
self.assertIsInstance(domain_config_vo, DomainConfig)
self.assertEqual(params['data'], domain_config_vo.data)
self.assertEqual(params['schema'], domain_config_vo.schema)
self.assertEqual(params['tags'], utils.tags_to_dict(domain_config_vo.tags))
self.assertEqual(params['domain_id'], domain_config_vo.domain_id)
def test_update_schema(self, *args):
new_schema_vo = SchemaFactory(domain_id=self.domain_id)
params = {
'name': new_schema_vo.name,
'schema': {
'type': 'object',
'properties': {
'domain': {
'title': 'Email Domain',
'type': 'string',
'minLength': 4,
'examples': ['Ex) gmail.com']
}
},
'required': ['domain']
},
'labels': ['ee', 'ff'],
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
schema_svc = SchemaService(transaction=self.transaction)
schema_vo = schema_svc.update(params.copy())
print_data(schema_vo.to_dict(), 'test_update_schema')
SchemaInfo(schema_vo)
self.assertIsInstance(schema_vo, Schema)
self.assertEqual(params['name'], schema_vo.name)
self.assertEqual(params.get('schema', {}), schema_vo.schema)
self.assertEqual(params.get('labels', []), schema_vo.labels)
self.assertEqual(params['tags'], utils.tags_to_dict(schema_vo.tags))
def UserChannelInfo(user_channel_vo: UserChannel, minimal=False):
info = {
'user_channel_id': user_channel_vo.user_channel_id,
'name': user_channel_vo.name,
'state': user_channel_vo.state
}
if not minimal:
info.update({
'data':
change_struct_type(user_channel_vo.data),
'secret_id':
user_channel_vo.secret_id,
'is_subscribe':
user_channel_vo.is_subscribe,
'subscriptions':
change_list_value_type(user_channel_vo.subscriptions),
'protocol_id':
user_channel_vo.protocol_id,
'user_id':
user_channel_vo.user_id,
'is_scheduled':
user_channel_vo.is_scheduled,
'schedule':
ScheduleInfo(user_channel_vo.schedule)
if user_channel_vo.schedule else user_channel_vo.schedule,
'created_at':
utils.datetime_to_iso8601(user_channel_vo.created_at),
'tags':
change_struct_type(utils.tags_to_dict(user_channel_vo.tags)),
'domain_id':
user_channel_vo.domain_id
})
return user_channel_pb2.UserChannelInfo(**info)
def ProjectGroupInfo(project_group_vo: ProjectGroup, minimal=False):
info = {
'project_group_id': project_group_vo.project_group_id,
'name': project_group_vo.name
}
if not minimal:
if project_group_vo.parent_project_group:
info.update({
'parent_project_group_info':
ProjectGroupInfo(project_group_vo.parent_project_group,
minimal=True)
})
info.update({
'tags':
change_struct_type(utils.tags_to_dict(project_group_vo.tags)),
'domain_id':
project_group_vo.domain_id,
'created_by':
project_group_vo.created_by,
'created_at':
utils.datetime_to_iso8601(project_group_vo.created_at)
})
return project_group_pb2.ProjectGroupInfo(**info)
def ProjectGroupRoleBindingInfo(role_binding_vo, minimal=False):
info = {
'role_binding_id':
role_binding_vo.role_binding_id,
'resource_type':
role_binding_vo.resource_type,
'resource_id':
role_binding_vo.resource_id,
'role_info':
RoleInfo(role_binding_vo.role, minimal=True)
if role_binding_vo.role else None
}
if not minimal:
info.update({
'project_group_info':
ProjectGroupInfo(role_binding_vo.project_group, minimal=True)
if role_binding_vo.project_group else None,
'labels':
change_list_value_type(role_binding_vo.labels),
'tags':
change_struct_type(utils.tags_to_dict(role_binding_vo.tags)),
'domain_id':
role_binding_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(role_binding_vo.created_at)
})
return project_group_pb2.ProjectGroupRoleBindingInfo(**info)
def ServiceAccountInfo(service_account_vo: ServiceAccount, minimal=False):
info = {
'service_account_id': service_account_vo.service_account_id,
'name': service_account_vo.name,
'provider': service_account_vo.provider
}
if not minimal:
info.update({
'data':
change_struct_type(service_account_vo.data),
'tags':
change_struct_type(utils.tags_to_dict(service_account_vo.tags)),
'domain_id':
service_account_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(service_account_vo.created_at)
})
if service_account_vo.project:
info.update({
'project_info':
ProjectInfo(service_account_vo.project, minimal=True)
})
return service_account_pb2.ServiceAccountInfo(**info)
def test_update_schedule(self, *args):
new_schedule_vo = ScheduleFactory(domain_id=self.domain_id)
params = {
'schedule_id': new_schedule_vo.storage_id,
'schedule': {
'cron': '*/5 * * * *'
},
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
schedule_svc = ScheduleService(transaction=self.transaction)
schedule_vo = schedule_svc.update(params.copy())
print_data(schedule_vo.to_dict(), 'test_update_schedule')
ScheduleInfo(schedule_vo)
self.assertIsInstance(schedule_vo, Schedule)
self.assertEqual(new_schedule_vo.storage_id, schedule_vo.schedule_id)
self.assertIsInstance(schedule_vo.schedule, Scheduled)
self.assertEqual(schedule_vo.schedule.cron, params['schedule']['cron'])
self.assertEqual(params['tags'], utils.tags_to_dict(schedule_vo.tags))
self.assertEqual(params['domain_id'], schedule_vo.domain_id)
def CloudServiceTypeInfo(cloud_svc_type_vo: CloudServiceType, minimal=False):
info = {
'cloud_service_type_id': cloud_svc_type_vo.cloud_service_type_id,
'name': cloud_svc_type_vo.name,
'provider': cloud_svc_type_vo.provider,
'group': cloud_svc_type_vo.group,
'service_code': cloud_svc_type_vo.service_code,
'is_primary': cloud_svc_type_vo.is_primary,
'is_major': cloud_svc_type_vo.is_major,
'resource_type': cloud_svc_type_vo.resource_type
}
if not minimal:
info.update({
'metadata':
change_struct_type(cloud_svc_type_vo.metadata),
'labels':
change_list_value_type(cloud_svc_type_vo.labels),
'tags':
change_struct_type(utils.tags_to_dict(cloud_svc_type_vo.tags)),
'domain_id':
cloud_svc_type_vo.domain_id,
'collection_info':
CollectionInfo(cloud_svc_type_vo.collection_info.to_dict()),
'created_at':
utils.datetime_to_iso8601(cloud_svc_type_vo.created_at),
'updated_at':
utils.datetime_to_iso8601(cloud_svc_type_vo.updated_at)
})
return cloud_service_type_pb2.CloudServiceTypeInfo(**info)
def test_update_user_config(self, *args):
new_user_config_vo = UserConfigFactory(domain_id=self.domain_id)
params = {
'name': new_user_config_vo.name,
'data': {
'update_data_key': 'update_data_value'
},
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
user_config_svc = UserConfigService(transaction=self.transaction)
user_config_vo = user_config_svc.update(params.copy())
print_data(user_config_vo.to_dict(), 'test_update_user_config')
UserConfigInfo(user_config_vo)
self.assertIsInstance(user_config_vo, UserConfig)
self.assertEqual(params['data'], user_config_vo.data)
self.assertEqual(params['tags'], utils.tags_to_dict(user_config_vo.tags))
self.assertEqual(params['domain_id'], user_config_vo.domain_id)
def PolicyInfo(policy_vo: Policy, minimal=False):
info = {'policy_id': policy_vo.policy_id, 'name': policy_vo.name}
if not minimal:
info.update({
'permissions':
change_list_value_type(policy_vo.permissions),
'tags':
change_struct_type(utils.tags_to_dict(policy_vo.tags)),
'domain_id':
policy_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(policy_vo.created_at)
})
return policy_pb2.PolicyInfo(**info)
def test_create_schema(self, *args):
params = {
'name': 'aws_access_key',
'service_type': 'secret.credentials',
'schema': {
'type': 'object',
'properties': {
'aws_access_key_id': {
'title': 'AWS Access Key',
'type': 'string',
'minLength': 4
},
'aws_secret_access_key': {
'title': 'AWS Secret Key',
'type': 'string',
'minLength': 4
},
'region_name': {
'title': "Region",
'type': 'string',
'minLength': 4,
'examples': ['ap-northeast-2']
}
},
'required': ['aws_access_key_id', 'aws_secret_access_key']
},
'labels': ['cc', 'dd'],
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'create'
schema_svc = SchemaService(transaction=self.transaction)
schema_vo = schema_svc.create(params.copy())
print_data(schema_vo.to_dict(), 'test_create_schema')
SchemaInfo(schema_vo)
self.assertIsInstance(schema_vo, Schema)
self.assertEqual(params['name'], schema_vo.name)
self.assertEqual(params['service_type'], schema_vo.service_type)
self.assertEqual(params.get('schema', {}), schema_vo.schema)
self.assertEqual(params.get('labels', []), schema_vo.labels)
self.assertEqual(params['tags'], utils.tags_to_dict(schema_vo.tags))
self.assertEqual(params['domain_id'], schema_vo.domain_id)
def test_update_data_source(self, mock_plugin_init, mock_list_secrets,
*args):
mock_plugin_init.return_value = {
'metadata': {
'supported_resource_type': ['inventory.Server'],
'supported_stat': ['AVERAGE', 'MAX', 'MIN'],
'required_keys': ['reference.resource_id']
}
}
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret')
}],
'total_count': 1
}
new_data_source_vo = DataSourceFactory(domain_id=self.domain_id)
params = {
'data_source_id': new_data_source_vo.data_source_id,
'name': 'Update AWS CloudWatch',
'plugin_info': {
'plugin_id': new_data_source_vo.plugin_info.plugin_id,
'version': '2.0',
'options': {},
'provider': 'aws'
},
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
data_source_svc = DataSourceService(transaction=self.transaction)
data_source_vo = data_source_svc.update(params.copy())
print_data(data_source_vo.to_dict(), 'test_update_data_source')
DataSourceInfo(data_source_vo)
self.assertIsInstance(data_source_vo, DataSource)
self.assertEqual(new_data_source_vo.data_source_id,
data_source_vo.data_source_id)
self.assertEqual(params['name'], data_source_vo.name)
self.assertEqual(params['tags'],
utils.tags_to_dict(data_source_vo.tags))
def DomainInfo(domain_vo: Domain, minimal=False):
info = {
'domain_id': domain_vo.domain_id,
'name': domain_vo.name,
'state': domain_vo.state
}
if not minimal:
info.update({
'plugin_info': PluginInfo(domain_vo.plugin_info),
'config': change_struct_type(domain_vo.config),
'created_at': utils.datetime_to_iso8601(domain_vo.created_at),
'deleted_at': utils.datetime_to_iso8601(domain_vo.deleted_at),
'tags': change_struct_type(utils.tags_to_dict(domain_vo.tags))
})
return domain_pb2.DomainInfo(**info)
def SupervisorInfo(supervisor_vo):
info = {
'supervisor_id': supervisor_vo.supervisor_id,
'name': supervisor_vo.name,
'hostname': supervisor_vo.hostname,
'state': supervisor_vo.state,
'is_public': supervisor_vo.is_public,
'labels': change_struct_type(supervisor_vo.labels),
'created_at': utils.datetime_to_iso8601(supervisor_vo.created_at),
'updated_at': utils.datetime_to_iso8601(supervisor_vo.updated_at),
'domain_id': supervisor_vo.domain_id
}
if supervisor_vo.tags:
info['tags'] = change_struct_type(utils.tags_to_dict(supervisor_vo.tags))
return supervisor_pb2.SupervisorInfo(**info)
def SecretGroupInfo(secret_group_vo: SecretGroup, minimal=False):
info = {
'secret_group_id': secret_group_vo.secret_group_id,
'name': secret_group_vo.name
}
if minimal is False:
info.update({
'tags':
change_struct_type(utils.tags_to_dict(secret_group_vo.tags)),
'domain_id':
secret_group_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(secret_group_vo.created_at)
})
return secret_group_pb2.SecretGroupInfo(**info)
def ResourceGroupInfo(rg_vo: ResourceGroup, minimal=False):
info = {
'resource_group_id': rg_vo.resource_group_id,
'name': rg_vo.name,
'project_id': rg_vo.project_id
}
if not minimal:
info.update({
'resources': list(map(ResourceInfo, rg_vo.resources)),
'options': change_struct_type(rg_vo.options),
'tags': change_struct_type(utils.tags_to_dict(rg_vo.tags)),
'domain_id': rg_vo.domain_id,
'created_at': utils.datetime_to_iso8601(rg_vo.created_at),
})
return resource_group_pb2.ResourceGroupInfo(**info)
def UserConfigInfo(user_config_vo: UserConfig, minimal=False):
info = {
'name': user_config_vo.name,
}
if not minimal:
info.update({
'data':
change_struct_type(user_config_vo.data),
'tags':
change_struct_type(utils.tags_to_dict(user_config_vo.tags)),
'domain_id':
user_config_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(user_config_vo.created_at)
})
return user_config_pb2.UserConfigInfo(**info)
def ProviderInfo(provider_vo: Provider, minimal=False):
info = {'provider': provider_vo.provider, 'name': provider_vo.name}
if not minimal:
info.update({
'template':
change_struct_type(provider_vo.template),
'metadata':
change_struct_type(provider_vo.metadata),
'capability':
change_struct_type(provider_vo.capability),
'tags':
change_struct_type(utils.tags_to_dict(provider_vo.tags)),
'created_at':
utils.datetime_to_iso8601(provider_vo.created_at)
})
return provider_pb2.ProviderInfo(**info)
def ScheduleInfo(schedule_vo: Schedule, minimal=False):
info = {
'schedule_id': schedule_vo.schedule_id,
'topic': schedule_vo.topic,
'state': schedule_vo.state,
}
if not minimal:
info.update({
'options': change_struct_type(schedule_vo.options) if schedule_vo.options else None,
'schedule': ScheduledInfo(schedule_vo.schedule) if schedule_vo.schedule else None,
'tags': change_struct_type(utils.tags_to_dict(schedule_vo.tags)),
'domain_id': schedule_vo.domain_id,
'created_at': utils.datetime_to_iso8601(schedule_vo.created_at),
'last_scheduled_at': utils.datetime_to_iso8601(schedule_vo.last_scheduled_at)
})
return schedule_pb2.ScheduleInfo(**info)
def PolicyInfo(policy_vo: Policy, minimal=False):
info = {'policy_id': policy_vo.policy_id, 'name': policy_vo.name}
if not minimal:
info.update({
'permissions':
change_list_value_type(policy_vo.permissions),
'labels':
change_list_value_type(policy_vo.labels),
'tags':
policy_vo.tags if isinstance(policy_vo.tags, Struct) else
change_struct_type(utils.tags_to_dict(policy_vo.tags)),
'project_id':
policy_vo.project_id,
'domain_id':
policy_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(policy_vo.created_at)
or policy_vo.created_at,
'updated_at':
utils.datetime_to_iso8601(policy_vo.updated_at)
or policy_vo.updated_at
})
# WARNING
# Based on local_policy or remote_policy
# vo has different repository or repository_info field
if getattr(policy_vo, 'repository', None):
info.update({
'repository_info':
RepositoryInfo(policy_vo.repository, minimal=True)
})
if getattr(policy_vo, 'repository_info', None):
info.update({
'repository_info':
RepositoryInfo(policy_vo.repository_info, minimal=True)
})
# Temporary code for DB migration
if not getattr(policy_vo, 'repository_id', None) and getattr(
policy_vo, 'repository', None):
policy_vo.update(
{'repository_id': policy_vo.repository.repository_id})
return policy_pb2.PolicyInfo(**info)
def SchemaInfo(schema_vo: Schema, minimal=False):
info = {'name': schema_vo.name, 'service_type': schema_vo.service_type}
if not minimal:
info.update({
'schema':
change_struct_type(schema_vo.schema),
'labels':
change_list_value_type(schema_vo.labels),
'tags':
schema_vo.tags if isinstance(schema_vo.tags, Struct) else
change_struct_type(utils.tags_to_dict(schema_vo.tags)),
'project_id':
schema_vo.project_id,
'domain_id':
schema_vo.domain_id,
'created_at':
utils.datetime_to_iso8601(schema_vo.created_at)
or schema_vo.created_at,
'updated_at':
utils.datetime_to_iso8601(schema_vo.updated_at)
or schema_vo.updated_at
})
# WARNING
# Based on local_schema or remote_schema
# vo has different repository or repository_info field
if getattr(schema_vo, 'repository', None):
info.update({
'repository_info':
RepositoryInfo(schema_vo.repository, minimal=True)
})
if getattr(schema_vo, 'repository_info', None):
info.update({
'repository_info':
RepositoryInfo(schema_vo.repository_info, minimal=True)
})
# Temporary code for DB migration
if not getattr(schema_vo, 'repository_id', None) and getattr(
schema_vo, 'repository', None):
schema_vo.update(
{'repository_id': schema_vo.repository.repository_id})
return schema_pb2.SchemaInfo(**info)
