Ejemplo n.º 1
0
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'task_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/policy/api/v1/tasks/{task-id}/response',
            path_variables={
                'task_id': 'task-id',
            },
            query_parameters={},
            content_type='application/json')

        operations = {
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType('vmware.vapi.dynamic_struct', {},
                                       VapiStruct),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx_policy.tasks.response',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
Ejemplo n.º 2
0
    def __init__(self, config):
        # properties for delete operation
        delete_input_type = type.StructType(
            'operation-input', {
                'service_id': type.StringType(),
                'service_entry_id': type.StringType(),
            })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template=
            '/policy/api/v1/infra/services/{service-id}/service-entries/{service-entry-id}',
            path_variables={
                'service_id': 'service-id',
                'service_entry_id': 'service-entry-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for get operation
        get_input_type = type.StructType(
            'operation-input', {
                'service_id': type.StringType(),
                'service_entry_id': type.StringType(),
            })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/policy/api/v1/infra/services/{service-id}/service-entries/{service-entry-id}',
            path_variables={
                'service_id': 'service-id',
                'service_entry_id': 'service-entry-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for list operation
        list_input_type = type.StructType(
            'operation-input', {
                'service_id':
                type.StringType(),
                'cursor':
                type.OptionalType(type.StringType()),
                'include_mark_for_delete_objects':
                type.OptionalType(type.BooleanType()),
                'included_fields':
                type.OptionalType(type.StringType()),
                'page_size':
                type.OptionalType(type.IntegerType()),
                'sort_ascending':
                type.OptionalType(type.BooleanType()),
                'sort_by':
                type.OptionalType(type.StringType()),
            })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/policy/api/v1/infra/services/{service-id}/service-entries',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={
                'cursor': 'cursor',
                'include_mark_for_delete_objects':
                'include_mark_for_delete_objects',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json')

        # properties for patch operation
        patch_input_type = type.StructType(
            'operation-input', {
                'service_id':
                type.StringType(),
                'service_entry_id':
                type.StringType(),
                'service_entry':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'ServiceEntry')
                    ]),
            })
        patch_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        patch_input_value_validator_list = [HasFieldsOfValidator()]
        patch_output_validator_list = []
        patch_rest_metadata = OperationRestMetadata(
            http_method='PATCH',
            url_template=
            '/policy/api/v1/infra/services/{service-id}/service-entries/{service-entry-id}',
            request_body_parameter='service_entry',
            path_variables={
                'service_id': 'service-id',
                'service_entry_id': 'service-entry-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for update operation
        update_input_type = type.StructType(
            'operation-input', {
                'service_id':
                type.StringType(),
                'service_entry_id':
                type.StringType(),
                'service_entry':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'ServiceEntry')
                    ]),
            })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template=
            '/policy/api/v1/infra/services/{service-id}/service-entries/{service-entry-id}',
            request_body_parameter='service_entry',
            path_variables={
                'service_id': 'service-id',
                'service_entry_id': 'service-entry-id',
            },
            query_parameters={},
            content_type='application/json')

        operations = {
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list':
                delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'ServiceEntry')
                    ]),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'list': {
                'input_type':
                list_input_type,
                'output_type':
                type.ReferenceType('com.vmware.nsx_policy.model_client',
                                   'ServiceEntryListResult'),
                'errors':
                list_error_dict,
                'input_value_validator_list':
                list_input_value_validator_list,
                'output_validator_list':
                list_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'patch': {
                'input_type': patch_input_type,
                'output_type': type.VoidType(),
                'errors': patch_error_dict,
                'input_value_validator_list': patch_input_value_validator_list,
                'output_validator_list': patch_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'update': {
                'input_type':
                update_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'ServiceEntry')
                    ]),
                'errors':
                update_error_dict,
                'input_value_validator_list':
                update_input_value_validator_list,
                'output_validator_list':
                update_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'patch': patch_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx_policy.infra.services.service_entries',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
    def __init__(self, config):
        # properties for create operation
        create_input_type = type.StructType(
            'operation-input', {
                'spec':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.vcenter.compute.policies_client',
                            'CreateSpec')
                    ]),
            })
        create_error_dict = {
            'com.vmware.vapi.std.errors.already_exists':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'AlreadyExists'),
            'com.vmware.vapi.std.errors.invalid_argument':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidArgument'),
            'com.vmware.vapi.std.errors.unable_to_allocate_resource':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'UnableToAllocateResource'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
        }
        create_input_value_validator_list = [HasFieldsOfValidator()]
        create_output_validator_list = []
        create_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/vcenter/compute/policies',
            path_variables={},
            query_parameters={})

        # properties for list operation
        list_input_type = type.StructType('operation-input', {})
        list_error_dict = {
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
        }
        list_input_value_validator_list = []
        list_output_validator_list = []
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/vcenter/compute/policies',
            path_variables={},
            query_parameters={})

        # properties for get operation
        get_input_type = type.StructType(
            'operation-input', {
                'policy':
                type.IdType(
                    resource_types='com.vmware.vcenter.compute.Policy'),
            })
        get_error_dict = {
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/vcenter/compute/policies/{policy}',
            path_variables={
                'policy': 'policy',
            },
            query_parameters={})

        # properties for delete operation
        delete_input_type = type.StructType(
            'operation-input', {
                'policy':
                type.IdType(
                    resource_types='com.vmware.vcenter.compute.Policy'),
            })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
        }
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/vcenter/compute/policies/{policy}',
            path_variables={
                'policy': 'policy',
            },
            query_parameters={})

        operations = {
            'create': {
                'input_type':
                create_input_type,
                'output_type':
                type.IdType(
                    resource_types='com.vmware.vcenter.compute.Policy'),
                'errors':
                create_error_dict,
                'input_value_validator_list':
                create_input_value_validator_list,
                'output_validator_list':
                create_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'list': {
                'input_type':
                list_input_type,
                'output_type':
                type.ListType(type.ReferenceType(__name__,
                                                 'Policies.Summary')),
                'errors':
                list_error_dict,
                'input_value_validator_list':
                list_input_value_validator_list,
                'output_validator_list':
                list_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.vcenter.compute.policies_client',
                            'Info')
                    ]),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list':
                delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
        }
        rest_metadata = {
            'create': create_rest_metadata,
            'list': list_rest_metadata,
            'get': get_rest_metadata,
            'delete': delete_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.vcenter.compute.policies',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=True)
Ejemplo n.º 4
0
    def __init__(self, config):
        # properties for create operation
        create_input_type = type.StructType(
            'operation-input', {
                'service_id':
                type.StringType(),
                'base_service_instance':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'BaseServiceInstance')
                    ]),
            })
        create_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        create_input_value_validator_list = [HasFieldsOfValidator()]
        create_output_validator_list = [HasFieldsOfValidator()]
        create_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template=
            '/api/v1/serviceinsertion/services/{service-id}/service-instances',
            request_body_parameter='base_service_instance',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for delete operation
        delete_input_type = type.StructType(
            'operation-input', {
                'service_id': type.StringType(),
                'service_instance_id': type.StringType(),
            })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template=
            '/api/v1/serviceinsertion/services/{service-id}/service-instances/{service-instance-id}',
            path_variables={
                'service_id': 'service-id',
                'service_instance_id': 'service-instance-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for get operation
        get_input_type = type.StructType(
            'operation-input', {
                'service_id': type.StringType(),
                'service_instance_id': type.StringType(),
            })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/api/v1/serviceinsertion/services/{service-id}/service-instances/{service-instance-id}',
            path_variables={
                'service_id': 'service-id',
                'service_instance_id': 'service-instance-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for list operation
        list_input_type = type.StructType('operation-input', {
            'service_id': type.StringType(),
        })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/api/v1/serviceinsertion/services/{service-id}/service-instances',
            path_variables={
                'service_id': 'service-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for update operation
        update_input_type = type.StructType(
            'operation-input', {
                'service_id':
                type.StringType(),
                'service_instance_id':
                type.StringType(),
                'base_service_instance':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'BaseServiceInstance')
                    ]),
            })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template=
            '/api/v1/serviceinsertion/services/{service-id}/service-instances/{service-instance-id}',
            request_body_parameter='base_service_instance',
            path_variables={
                'service_id': 'service-id',
                'service_instance_id': 'service-instance-id',
            },
            query_parameters={},
            content_type='application/json')

        operations = {
            'create': {
                'input_type':
                create_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'BaseServiceInstance')
                    ]),
                'errors':
                create_error_dict,
                'input_value_validator_list':
                create_input_value_validator_list,
                'output_validator_list':
                create_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list':
                delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'BaseServiceInstance')
                    ]),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'list': {
                'input_type':
                list_input_type,
                'output_type':
                type.ReferenceType('com.vmware.nsx.model_client',
                                   'ServiceInstanceListResult'),
                'errors':
                list_error_dict,
                'input_value_validator_list':
                list_input_value_validator_list,
                'output_validator_list':
                list_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'update': {
                'input_type':
                update_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'BaseServiceInstance')
                    ]),
                'errors':
                update_error_dict,
                'input_value_validator_list':
                update_input_value_validator_list,
                'output_validator_list':
                update_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'create': create_rest_metadata,
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name=
            'com.vmware.nsx.serviceinsertion.services.service_instances',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
        self.messages = messages
        self.data = data
        VapiError.__init__(self)


Error._set_binding_type(
    type.ErrorType(
        'com.vmware.vcenter.tokenservice.error', {
            'messages':
            type.ListType(
                type.ReferenceType('com.vmware.vapi.std_client',
                                   'LocalizableMessage')),
            'data':
            type.OptionalType(
                type.DynamicStructType('vmware.vapi.dynamic_struct', {},
                                       VapiStruct)),
        }, Error))


class InvalidScope(Error):
    """
    The ``InvalidScope`` exception indicates requested scope is invalid,
    unknown, malformed, or exceeds the scope granted by the resource owner.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """

    _qualname = 'InvalidScope'
            """
            Enum.__init__(string)

    ResultType._set_values([
        ResultType('NORMAL_RESULT'),
        ResultType('ERROR_RESULT'),
    ])
    ResultType._set_binding_type(type.EnumType(
        'com.vmware.vapi.std.interposition.invocation_result.result_type',
        ResultType))

InvocationResult._set_binding_type(type.StructType(
    'com.vmware.vapi.std.interposition.invocation_result', {
        'result_type': type.ReferenceType(__name__, 'InvocationResult.ResultType'),
        'output': type.OptionalType(type.OpaqueType()),
        'error': type.OptionalType(type.DynamicStructType('vmware.vapi.dynamic_struct', {}, VapiStruct)),
    },
    InvocationResult,
    False,
    None))



class SecurityPrincipal(VapiStruct):
    """
    VMODL equivalent of com.vmware.vapi.security.PrincipalId.

    .. tip::
        The arguments are used to initialize data attributes with the same
        names.
    """
    def __init__(self, config):
        # properties for get operation
        get_input_type = type.StructType(
            'operation-input', {
                'org': type.StringType(),
                'sddc': type.StringType(),
                'edge_id': type.StringType(),
                'objecttype': type.StringType(),
                'objectid': type.StringType(),
                'templateid': type.OptionalType(type.StringType()),
            })
        get_error_dict = {
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = []
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/vmc/api/orgs/{org}/sddcs/{sddc}/networks/4.0/edges/{edgeId}/peerconfig',
            path_variables={
                'org': 'org',
                'sddc': 'sddc',
                'edge_id': 'edgeId',
            },
            query_parameters={
                'objecttype': 'objecttype',
                'objectid': 'objectid',
                'templateid': 'templateid',
            },
            content_type='application/json')

        operations = {
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType('vmware.vapi.dynamic_struct', {},
                                       VapiStruct),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'get': get_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.vmc.orgs.sddcs.networks.edges.peerconfig',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
Ejemplo n.º 8
0
    def __init__(self, config):
        # properties for create operation
        create_input_type = type.StructType(
            'operation-input', {
                'directory_domain':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
            })
        create_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        create_input_value_validator_list = [HasFieldsOfValidator()]
        create_output_validator_list = [HasFieldsOfValidator()]
        create_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/api/v1/directory/domains',
            request_body_parameter='directory_domain',
            path_variables={},
            query_parameters={},
            content_type='application/json')

        # properties for create_0 operation
        create_0_input_type = type.StructType(
            'operation-input', {
                'domain_id': type.StringType(),
                'action': type.StringType(),
                'delay': type.OptionalType(type.IntegerType()),
            })
        create_0_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        create_0_input_value_validator_list = []
        create_0_output_validator_list = []
        create_0_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/api/v1/directory/domains/{domain-id}',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={
                'action': 'action',
                'delay': 'delay',
            },
            content_type='application/json')

        # properties for delete operation
        delete_input_type = type.StructType(
            'operation-input', {
                'domain_id': type.StringType(),
                'force': type.OptionalType(type.BooleanType()),
            })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template='/api/v1/directory/domains/{domain-id}',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={
                'force': 'force',
            },
            content_type='application/json')

        # properties for get operation
        get_input_type = type.StructType('operation-input', {
            'domain_id': type.StringType(),
        })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/api/v1/directory/domains/{domain-id}',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for list operation
        list_input_type = type.StructType(
            'operation-input', {
                'cursor': type.OptionalType(type.StringType()),
                'included_fields': type.OptionalType(type.StringType()),
                'page_size': type.OptionalType(type.IntegerType()),
                'sort_ascending': type.OptionalType(type.BooleanType()),
                'sort_by': type.OptionalType(type.StringType()),
            })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/api/v1/directory/domains',
            path_variables={},
            query_parameters={
                'cursor': 'cursor',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json')

        # properties for update operation
        update_input_type = type.StructType(
            'operation-input', {
                'domain_id':
                type.StringType(),
                'directory_domain':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
            })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template='/api/v1/directory/domains/{domain-id}',
            request_body_parameter='directory_domain',
            path_variables={
                'domain_id': 'domain-id',
            },
            query_parameters={},
            content_type='application/json')

        operations = {
            'create': {
                'input_type':
                create_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
                'errors':
                create_error_dict,
                'input_value_validator_list':
                create_input_value_validator_list,
                'output_validator_list':
                create_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'create_0': {
                'input_type': create_0_input_type,
                'output_type': type.VoidType(),
                'errors': create_0_error_dict,
                'input_value_validator_list':
                create_0_input_value_validator_list,
                'output_validator_list': create_0_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list':
                delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'list': {
                'input_type':
                list_input_type,
                'output_type':
                type.ReferenceType('com.vmware.nsx.model_client',
                                   'DirectoryDomainListResults'),
                'errors':
                list_error_dict,
                'input_value_validator_list':
                list_input_value_validator_list,
                'output_validator_list':
                list_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'update': {
                'input_type':
                update_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
                'errors':
                update_error_dict,
                'input_value_validator_list':
                update_input_value_validator_list,
                'output_validator_list':
                update_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'create': create_rest_metadata,
            'create_0': create_0_rest_metadata,
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'list': list_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx.directory.domains',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
    def __init__(self, config):
        # properties for create operation
        create_input_type = type.StructType(
            'operation-input', {
                'directory_domain':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'DirectoryDomain')
                    ]),
            })
        create_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        create_input_value_validator_list = [HasFieldsOfValidator()]
        create_output_validator_list = []
        create_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template='/api/v1/directory/domain-size',
            request_body_parameter='directory_domain',
            path_variables={},
            query_parameters={},
            content_type='application/json')

        operations = {
            'create': {
                'input_type':
                create_input_type,
                'output_type':
                type.ReferenceType('com.vmware.nsx.model_client',
                                   'DirectoryDomainSize'),
                'errors':
                create_error_dict,
                'input_value_validator_list':
                create_input_value_validator_list,
                'output_validator_list':
                create_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'create': create_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx.directory.domain_size',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
Ejemplo n.º 10
0
    def __init__(self, config):
        # properties for create operation
        create_input_type = type.StructType(
            'operation-input', {
                'view_id':
                type.StringType(),
                'widget_configuration':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'WidgetConfiguration')
                    ]),
            })
        create_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        create_input_value_validator_list = [HasFieldsOfValidator()]
        create_output_validator_list = [HasFieldsOfValidator()]
        create_rest_metadata = OperationRestMetadata(
            http_method='POST',
            url_template=
            '/policy/api/v1/ui-views/{view-id}/widgetconfigurations',
            request_body_parameter='widget_configuration',
            path_variables={
                'view_id': 'view-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for delete operation
        delete_input_type = type.StructType(
            'operation-input', {
                'view_id': type.StringType(),
                'widgetconfiguration_id': type.StringType(),
            })
        delete_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        delete_input_value_validator_list = []
        delete_output_validator_list = []
        delete_rest_metadata = OperationRestMetadata(
            http_method='DELETE',
            url_template=
            '/policy/api/v1/ui-views/{view-id}/widgetconfigurations/{widgetconfiguration-id}',
            path_variables={
                'view_id': 'view-id',
                'widgetconfiguration_id': 'widgetconfiguration-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for get operation
        get_input_type = type.StructType(
            'operation-input', {
                'view_id': type.StringType(),
                'container': type.OptionalType(type.StringType()),
                'widget_ids': type.OptionalType(type.StringType()),
            })
        get_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_input_value_validator_list = []
        get_output_validator_list = [HasFieldsOfValidator()]
        get_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/policy/api/v1/ui-views/{view-id}/widgetconfigurations',
            path_variables={
                'view_id': 'view-id',
            },
            query_parameters={
                'container': 'container',
                'widget_ids': 'widget_ids',
            },
            content_type='application/json')

        # properties for get_0 operation
        get_0_input_type = type.StructType(
            'operation-input', {
                'view_id': type.StringType(),
                'widgetconfiguration_id': type.StringType(),
            })
        get_0_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        get_0_input_value_validator_list = []
        get_0_output_validator_list = [HasFieldsOfValidator()]
        get_0_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template=
            '/policy/api/v1/ui-views/{view-id}/widgetconfigurations/{widgetconfiguration-id}',
            path_variables={
                'view_id': 'view-id',
                'widgetconfiguration_id': 'widgetconfiguration-id',
            },
            query_parameters={},
            content_type='application/json')

        # properties for update operation
        update_input_type = type.StructType(
            'operation-input', {
                'view_id':
                type.StringType(),
                'widgetconfiguration_id':
                type.StringType(),
                'widget_configuration':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'WidgetConfiguration')
                    ]),
            })
        update_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        update_input_value_validator_list = [HasFieldsOfValidator()]
        update_output_validator_list = [HasFieldsOfValidator()]
        update_rest_metadata = OperationRestMetadata(
            http_method='PUT',
            url_template=
            '/policy/api/v1/ui-views/{view-id}/widgetconfigurations/{widgetconfiguration-id}',
            request_body_parameter='widget_configuration',
            path_variables={
                'view_id': 'view-id',
                'widgetconfiguration_id': 'widgetconfiguration-id',
            },
            query_parameters={},
            content_type='application/json')

        operations = {
            'create': {
                'input_type':
                create_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'WidgetConfiguration')
                    ]),
                'errors':
                create_error_dict,
                'input_value_validator_list':
                create_input_value_validator_list,
                'output_validator_list':
                create_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'delete': {
                'input_type': delete_input_type,
                'output_type': type.VoidType(),
                'errors': delete_error_dict,
                'input_value_validator_list':
                delete_input_value_validator_list,
                'output_validator_list': delete_output_validator_list,
                'task_type': TaskType.NONE,
            },
            'get': {
                'input_type':
                get_input_type,
                'output_type':
                type.ReferenceType('com.vmware.nsx_policy.model_client',
                                   'WidgetConfigurationList'),
                'errors':
                get_error_dict,
                'input_value_validator_list':
                get_input_value_validator_list,
                'output_validator_list':
                get_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'get_0': {
                'input_type':
                get_0_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'WidgetConfiguration')
                    ]),
                'errors':
                get_0_error_dict,
                'input_value_validator_list':
                get_0_input_value_validator_list,
                'output_validator_list':
                get_0_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
            'update': {
                'input_type':
                update_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType(
                            'com.vmware.nsx_policy.model_client',
                            'WidgetConfiguration')
                    ]),
                'errors':
                update_error_dict,
                'input_value_validator_list':
                update_input_value_validator_list,
                'output_validator_list':
                update_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'create': create_rest_metadata,
            'delete': delete_rest_metadata,
            'get': get_rest_metadata,
            'get_0': get_0_rest_metadata,
            'update': update_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx_policy.ui_views.widgetconfigurations',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)
Ejemplo n.º 11
0
    def __init__(self, config):
        # properties for list operation
        list_input_type = type.StructType(
            'operation-input', {
                'nsgroup_id':
                type.StringType(),
                'service_type':
                type.StringType(),
                'cursor':
                type.OptionalType(type.StringType()),
                'fetch_parentgroup_associations':
                type.OptionalType(type.BooleanType()),
                'included_fields':
                type.OptionalType(type.StringType()),
                'page_size':
                type.OptionalType(type.IntegerType()),
                'sort_ascending':
                type.OptionalType(type.BooleanType()),
                'sort_by':
                type.OptionalType(type.StringType()),
            })
        list_error_dict = {
            'com.vmware.vapi.std.errors.service_unavailable':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'ServiceUnavailable'),
            'com.vmware.vapi.std.errors.invalid_request':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InvalidRequest'),
            'com.vmware.vapi.std.errors.internal_server_error':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'InternalServerError'),
            'com.vmware.vapi.std.errors.unauthorized':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'Unauthorized'),
            'com.vmware.vapi.std.errors.not_found':
            type.ReferenceType('com.vmware.vapi.std.errors_client',
                               'NotFound'),
        }
        list_input_value_validator_list = []
        list_output_validator_list = [HasFieldsOfValidator()]
        list_rest_metadata = OperationRestMetadata(
            http_method='GET',
            url_template='/api/v1/ns-groups/{nsgroup-id}/service-associations',
            path_variables={
                'nsgroup_id': 'nsgroup-id',
            },
            query_parameters={
                'service_type': 'service_type',
                'cursor': 'cursor',
                'fetch_parentgroup_associations':
                'fetch_parentgroup_associations',
                'included_fields': 'included_fields',
                'page_size': 'page_size',
                'sort_ascending': 'sort_ascending',
                'sort_by': 'sort_by',
            },
            content_type='application/json')

        operations = {
            'list': {
                'input_type':
                list_input_type,
                'output_type':
                type.DynamicStructType(
                    'vmware.vapi.dynamic_struct', {}, VapiStruct, [
                        type.ReferenceType('com.vmware.nsx.model_client',
                                           'ServiceAssociationListResult')
                    ]),
                'errors':
                list_error_dict,
                'input_value_validator_list':
                list_input_value_validator_list,
                'output_validator_list':
                list_output_validator_list,
                'task_type':
                TaskType.NONE,
            },
        }
        rest_metadata = {
            'list': list_rest_metadata,
        }
        ApiInterfaceStub.__init__(
            self,
            iface_name='com.vmware.nsx.ns_groups.service_associations',
            config=config,
            operations=operations,
            rest_metadata=rest_metadata,
            is_vapi_rest=False)