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)