Source code for com.vmware.content_client

# -*- coding: utf-8 -*-
#---------------------------------------------------------------------------
# Copyright 2016 VMware, Inc.  All rights reserved.

# AUTO GENERATED FILE -- DO NOT MODIFY!
#
# vAPI stub file for package com.vmware.content.
#---------------------------------------------------------------------------

"""
The Content module provides classes and classes for configuring global settings
and permissions, and for managing libraries in the Content Library Service.

"""

__author__ = 'VMware, Inc.'
__docformat__ = 'restructuredtext en'

import sys

from vmware.vapi.bindings import type
from vmware.vapi.bindings.converter import TypeConverter
from vmware.vapi.bindings.enum import Enum
from vmware.vapi.bindings.error import VapiError
from vmware.vapi.bindings.struct import VapiStruct
from vmware.vapi.bindings.stub import VapiInterface, ApiInterfaceStub
from vmware.vapi.bindings.common import raise_core_exception
from vmware.vapi.data.validator import UnionValidator, HasFieldsOfValidator
from vmware.vapi.exception import CoreException
import com.vmware.vapi.std.errors_client
import com.vmware.vapi.std_client
import com.vmware.content.library_client


[docs]class ConfigurationModel(VapiStruct): """ The ``ConfigurationModel`` class defines the global settings of the Content Library Service. .. tip:: The arguments are used to initialize data attributes with the same names. """ def __init__(self, automatic_sync_enabled=None, automatic_sync_start_hour=None, automatic_sync_stop_hour=None, maximum_concurrent_item_syncs=None, ): """ :type automatic_sync_enabled: :class:`bool` :param automatic_sync_enabled: Whether automatic synchronization is enabled. When automatic synchronization is enabled, the Content Library Service will automatically synchronize all subscribed libraries on a daily basis. Subscribed libraries with the :attr:`com.vmware.content.library_client.SubscriptionInfo.automatic_sync_enabled` flag turned on will be synchronized every hour between :attr:`ConfigurationModel.automatic_sync_start_hour` and :attr:`ConfigurationModel.automatic_sync_stop_hour`. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. :type automatic_sync_start_hour: :class:`long` :param automatic_sync_start_hour: The hour at which the automatic synchronization will start. This value is between 0 (midnight) and 23 inclusive. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. :type automatic_sync_stop_hour: :class:`long` :param automatic_sync_stop_hour: The hour at which the automatic synchronization will stop. Any active synchronization operation will continue to run, however no new synchronization operations will be triggered after the stop hour. This value is between 0 (midnight) and 23 inclusive. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. :type maximum_concurrent_item_syncs: :class:`long` :param maximum_concurrent_item_syncs: The maximum allowed number of library items to synchronize concurrently from remote libraries. This must be a positive number. The service may not be able to guarantee the requested concurrency if there is no available capacity. This setting is global across all subscribed libraries. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. """ self.automatic_sync_enabled = automatic_sync_enabled self.automatic_sync_start_hour = automatic_sync_start_hour self.automatic_sync_stop_hour = automatic_sync_stop_hour self.maximum_concurrent_item_syncs = maximum_concurrent_item_syncs VapiStruct.__init__(self)
ConfigurationModel._set_binding_type(type.StructType( 'com.vmware.content.configuration_model', { 'automatic_sync_enabled': type.OptionalType(type.BooleanType()), 'automatic_sync_start_hour': type.OptionalType(type.IntegerType()), 'automatic_sync_stop_hour': type.OptionalType(type.IntegerType()), 'maximum_concurrent_item_syncs': type.OptionalType(type.IntegerType()), }, ConfigurationModel, False, None))
[docs]class LibraryModel(VapiStruct): """ The :class:`LibraryModel` class represents a Content Library resource model. A ``LibraryModel`` is a container for a set of items which represent a usable set of files. The Content Library Service allows for multiple libraries to be created with separate authorization and sharing policies. Each ``LibraryModel`` is a container for a set of :class:`com.vmware.content.library_client.ItemModel` instances. Each item is a logical object in a library, which may have multiple files. A ``LibraryModel`` may be local or subscribed. A local library has its source of truth about items within this Content Library Service. Items may be added to or removed from the library. A local library may also be private or published. When published, the library is exposed by a network endpoint and can be used by another Content Library Service for synchronization. A private local library cannot be used for synchronization. A subscribed library is a library which gets its source of truth from another library that may be across a network in another Content Library Service. A subscribed library may have a different name and metadata from the library to which it subscribes, but the set of library items is always the same as those in the source library. Library items cannot be manually added to a subscribed library -- they can only be added by adding new items to the source library. .. tip:: The arguments are used to initialize data attributes with the same names. """ def __init__(self, id=None, creation_time=None, description=None, last_modified_time=None, last_sync_time=None, name=None, storage_backings=None, type=None, optimization_info=None, version=None, publish_info=None, subscription_info=None, server_guid=None, ): """ :type id: :class:`str` :param id: An identifier which uniquely identifies this ``LibraryModel``. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``com.vmware.content.Library``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``com.vmware.content.Library``. This attribute is not used for the ``create`` method. It will not be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type creation_time: :class:`datetime.datetime` :param creation_time: The date and time when this library was created. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type description: :class:`str` :param description: A human-readable description for this library. This attribute is optional for the ``create`` method. Leaving it None during creation will result in an empty string value. It will always be present in the result of a ``get`` or ``list`` method. It is optional for the ``update`` method. Leaving it None during update indicates that the description should be left unchanged. :type last_modified_time: :class:`datetime.datetime` :param last_modified_time: The date and time when this library was last updated. This attribute is updated automatically when the library properties are changed. This attribute is not affected by adding, removing, or modifying a library item or its content within the library. Tagging the library or syncing the subscribed library does not alter this attribute. This attribute is not used for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type last_sync_time: :class:`datetime.datetime` :param last_sync_time: The date and time when this library was last synchronized. This attribute applies only to subscribed libraries. It is updated every time a synchronization is triggered on the library. The value is None for a local library. This attribute is not used for the ``create`` method. It is optional in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type name: :class:`str` :param name: The name of the library. A Library is identified by a human-readable name. Library names cannot be undefined or an empty string. Names do not have to be unique. This attribute must be provided for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. :type storage_backings: :class:`list` of :class:`com.vmware.content.library_client.StorageBacking` :param storage_backings: The list of storage backings which are available for this library. A :class:`com.vmware.content.library_client.StorageBacking` defines a storage location which can be used to store files for the library items in this library. Multiple storage locations are not currently supported but may become supported in future releases. This attribute must be provided for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type type: :class:`LibraryModel.LibraryType` :param type: The type (LOCAL, SUBSCRIBED) of this library. This value can be used to determine what additional services and information can be available for this library. This attribute must be provided for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. :type optimization_info: :class:`com.vmware.content.library_client.OptimizationInfo` :param optimization_info: Defines various optimizations and optimization parameters applied to this library. This attribute is optional for the ``create`` method. It is optional in the return value of the ``get`` or ``list`` methods. It is optional for the ``update`` method. :type version: :class:`str` :param version: A version number which is updated on metadata changes. This value allows clients to detect concurrent updates and prevent accidental clobbering of data. This value represents a number which is incremented every time library properties, such as name or description, are changed. It is not incremented by changes to a library item within the library, including adding or removing items. It is also not affected by tagging the library. This attribute is not used for the ``create`` method. It will always be present in the result of a ``get`` or ``list`` method. It is optional for the ``update`` method. Leaving it None during update indicates that you do not need to detect concurrent updates. :type publish_info: :class:`com.vmware.content.library_client.PublishInfo` :param publish_info: Defines how this library is published so that it can be subscribed to by a remote subscribed library. The :class:`com.vmware.content.library_client.PublishInfo` defines where and how the metadata for this local library is accessible. A local library is only published publically if :attr:`com.vmware.content.library_client.PublishInfo.published` is ``true``. This attribute is optional for the ``create`` and ``update`` methods. If not specified during creation, the default is for the library to not be published. If not specified during update, the attribute is left unchanged. :type subscription_info: :class:`com.vmware.content.library_client.SubscriptionInfo` :param subscription_info: Defines the subscription behavior for this Library. The :class:`com.vmware.content.library_client.SubscriptionInfo` defines how this subscribed library synchronizes to a remote source. Setting the value will determine the remote source to which the library synchronizes, and how. Changing the subscription will result in synchronizing to a new source. If the new source differs from the old one, the old library items and data will be lost. Setting :attr:`com.vmware.content.library_client.SubscriptionInfo.automatic_sync_enabled` to false will halt subscription but will not remove existing cached data. This attribute is optional for the ``create`` and ``update`` methods. If not specified during creation, a default will be created without an active subscription. If not specified during update, the attribute is left unchanged. :type server_guid: :class:`str` :param server_guid: The unique identifier of the vCenter server where the library exists. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``com.vmware.vcenter.VCenter``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``com.vmware.vcenter.VCenter``. This attribute is optional for the ``create`` method. It will always be present in the return value of the ``get`` or ``list`` methods. It is not used for the ``update`` method. """ self.id = id self.creation_time = creation_time self.description = description self.last_modified_time = last_modified_time self.last_sync_time = last_sync_time self.name = name self.storage_backings = storage_backings self.type = type self.optimization_info = optimization_info self.version = version self.publish_info = publish_info self.subscription_info = subscription_info self.server_guid = server_guid VapiStruct.__init__(self)
[docs] class LibraryType(Enum): """ The ``LibraryModel.LibraryType`` class defines the type of a :class:`LibraryModel`. The type of a library can be used to determine which additional services can be performed with a library. .. note:: This class represents an enumerated type in the interface language definition. The class contains class attributes which represent the values in the current version of the enumerated type. Newer versions of the enumerated type may contain new values. To use new values of the enumerated type in communication with a server that supports the newer version of the API, you instantiate this class. See :ref:`enumerated type description page <enumeration_description>`. """ LOCAL = None """ The library contents are defined and stored by the local Content Library Service installation. A local library can be retrieved and managed via the :class:`LocalLibrary`. """ SUBSCRIBED = None """ The library synchronizes its items and content from another published library. A subscribed library can be retrieved and managed via the :class:`SubscribedLibrary`. """ def __init__(self, string): """ :type string: :class:`str` :param string: String value for the :class:`LibraryType` instance. """ Enum.__init__(string)
LibraryType._set_values([ LibraryType('LOCAL'), LibraryType('SUBSCRIBED'), ]) LibraryType._set_binding_type(type.EnumType( 'com.vmware.content.library_model.library_type', LibraryType))
LibraryModel._set_binding_type(type.StructType( 'com.vmware.content.library_model', { 'id': type.OptionalType(type.IdType()), 'creation_time': type.OptionalType(type.DateTimeType()), 'description': type.OptionalType(type.StringType()), 'last_modified_time': type.OptionalType(type.DateTimeType()), 'last_sync_time': type.OptionalType(type.DateTimeType()), 'name': type.OptionalType(type.StringType()), 'storage_backings': type.OptionalType(type.ListType(type.ReferenceType(com.vmware.content.library_client, 'StorageBacking'))), 'type': type.OptionalType(type.ReferenceType(sys.modules[__name__], 'LibraryModel.LibraryType')), 'optimization_info': type.OptionalType(type.ReferenceType(com.vmware.content.library_client, 'OptimizationInfo')), 'version': type.OptionalType(type.StringType()), 'publish_info': type.OptionalType(type.ReferenceType(com.vmware.content.library_client, 'PublishInfo')), 'subscription_info': type.OptionalType(type.ReferenceType(com.vmware.content.library_client, 'SubscriptionInfo')), 'server_guid': type.OptionalType(type.IdType()), }, LibraryModel, True, ["id"]))
[docs]class Configuration(VapiInterface): """ The ``Configuration`` class provides methods to configure the global settings of the Content Library Service. The configuration settings are used by the Content Library Service to control the behavior of various operations. """ def __init__(self, config): """ :type config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param config: Configuration to be used for creating the stub. """ VapiInterface.__init__(self, config, _ConfigurationStub)
[docs] def update(self, model, ): """ Updates the configuration. The update is incremental. Any attribute in the :class:`ConfigurationModel` class that is None will not be modified. Note that this update method doesn't guarantee an atomic change of all the properties. In the case of a system crash or failure, some of the properties could be left unchanged while others may be updated. :type model: :class:`ConfigurationModel` :param model: The :class:`ConfigurationModel` specifying the settings to update. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if one of the configuration properties is not within the proper range. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.UpdateConfiguration``. """ return self._invoke('update', { 'model': model, })
[docs] def get(self): """ Retrieves the current configuration values. :rtype: :class:`ConfigurationModel` :return: The :class:`ConfigurationModel` instance representing the configuration of the Content Library Service. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.GetConfiguration``. """ return self._invoke('get', None)
[docs]class Library(VapiInterface): """ The ``Library`` class provides methods to manage and find :class:`LibraryModel` entities. The ``Library`` class provides support for generic functionality which can be applied equally to all types of libraries. The functionality provided by this class will not affect the properties specific to the type of library. See also :class:`LocalLibrary` and :class:`SubscribedLibrary`. """ RESOURCE_TYPE = "com.vmware.content.Library" """ Resource type for library. """ def __init__(self, config): """ :type config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param config: Configuration to be used for creating the stub. """ VapiInterface.__init__(self, config, _LibraryStub)
[docs] class FindSpec(VapiStruct): """ Specifies the properties that can be used as a filter to find libraries. When multiple attributes are specified, all properties of the library must match the specification. .. tip:: The arguments are used to initialize data attributes with the same names. """ def __init__(self, name=None, type=None, ): """ :type name: :class:`str` or ``None`` :param name: Name of the library to search. The name is case-insensitive. See :attr:`LibraryModel.name`. If not specified any name will be searched. :type type: :class:`LibraryModel.LibraryType` or ``None`` :param type: Library type to search. See :attr:`LibraryModel.type`. If not specified any library type will be searched. """ self.name = name self.type = type VapiStruct.__init__(self)
FindSpec._set_binding_type(type.StructType( 'com.vmware.content.library.find_spec', { 'name': type.OptionalType(type.StringType()), 'type': type.OptionalType(type.ReferenceType(sys.modules[__name__], 'LibraryModel.LibraryType')), }, FindSpec, False, None))
[docs] def get(self, library_id, ): """ Returns a given :class:`LibraryModel`. :type library_id: :class:`str` :param library_id: Identifier of the library to return. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :rtype: :class:`LibraryModel` :return: The :class:`LibraryModel` instance with the specified ``library_id``. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the specified library does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``System.Read``. """ return self._invoke('get', { 'library_id': library_id, })
[docs] def list(self): """ Returns the identifiers of all libraries of any type in the Content Library. :rtype: :class:`list` of :class:`str` :return: The :class:`list` of all identifiers of all libraries in the Content Library. The return value will contain identifiers for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``System.Read``. """ return self._invoke('list', None)
[docs] def find(self, spec, ): """ Returns a list of all the visible (as determined by authorization policy) libraries matching the requested :class:`Library.FindSpec`. :type spec: :class:`Library.FindSpec` :param spec: Specification describing what properties to filter on. :rtype: :class:`list` of :class:`str` :return: The :class:`list` of identifiers of all the visible libraries matching the given ``spec``. The return value will contain identifiers for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if no properties are specified in the ``spec``. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``System.Read``. """ return self._invoke('find', { 'spec': spec, })
[docs] def update(self, library_id, update_spec, ): """ Updates the properties of a library. This is an incremental update to the library. Any attribute in the :class:`LibraryModel` class that is None will not be modified. This method will only update the common properties for all library types. This will not, for example, update the :attr:`LibraryModel.publish_info` of a local library, nor the :attr:`LibraryModel.subscription_info` of a subscribed library. Specific properties are updated in :func:`LocalLibrary.update` and :func:`SubscribedLibrary.update`. :type library_id: :class:`str` :param library_id: Identifier of the library to update. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :type update_spec: :class:`LibraryModel` :param update_spec: Specification of the new property values to set on the library. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library associated with ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``update_spec`` is not valid. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the :attr:`LibraryModel.version` of ``update_spec`` is not equal to the current version of the library. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.UpdateLibrary``. """ return self._invoke('update', { 'library_id': library_id, 'update_spec': update_spec, })
[docs]class LocalLibrary(VapiInterface): """ The ``LocalLibrary`` class manages local libraries. The ``LocalLibrary`` class provides support for creating and maintaining local library instances. A local library may also use the :class:`Library` class to manage general library functionality. """ def __init__(self, config): """ :type config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param config: Configuration to be used for creating the stub. """ VapiInterface.__init__(self, config, _LocalLibraryStub)
[docs] def create(self, create_spec, client_token=None, ): """ Creates a new local library. :type client_token: :class:`str` or ``None`` :param client_token: A unique token generated on the client for each creation request. The token should be a universally unique identifier (UUID), for example: ``b8a2a2e3-2314-43cd-a871-6ede0f429751``. This token can be used to guarantee idempotent creation. If not specified creation is not idempotent. :type create_spec: :class:`LibraryModel` :param create_spec: Specification for the new local library. :rtype: :class:`str` :return: Identifier of the newly created :class:`LibraryModel`. The return value will be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``create_spec`` is not valid. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``client_token`` does not conform to the UUID format. :raise: :class:`com.vmware.vapi.std.errors_client.Unsupported` if using multiple storage backings. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.CreateLocalLibrary``. """ return self._invoke('create', { 'client_token': client_token, 'create_spec': create_spec, })
[docs] def delete(self, library_id, ): """ Deletes the specified local library. Deleting a local library will remove the entry immediately and begin an asynchronous task to remove all cached content for the library. If the asynchronous task fails, file content may remain on the storage backing. This content will require manual removal. :type library_id: :class:`str` :param library_id: Identifier of the local library to delete. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a local library. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.DeleteLocalLibrary``. """ return self._invoke('delete', { 'library_id': library_id, })
[docs] def get(self, library_id, ): """ Returns a given local library. :type library_id: :class:`str` :param library_id: Identifier of the local library to return. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :rtype: :class:`LibraryModel` :return: The :class:`LibraryModel` instance associated with ``library_id``. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a local library. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``System.Read``. """ return self._invoke('get', { 'library_id': library_id, })
[docs] def list(self): """ Returns the identifiers of all local libraries in the Content Library. :rtype: :class:`list` of :class:`str` :return: The :class:`list` of identifiers of all local libraries in the Content Library. The return value will contain identifiers for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``System.Read``. """ return self._invoke('list', None)
[docs] def update(self, library_id, update_spec, ): """ Updates the properties of a local library. This is an incremental update to the local library. Attributes that are None in the update specification will be left unchanged. :type library_id: :class:`str` :param library_id: Identifier of the local library to update. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :type update_spec: :class:`LibraryModel` :param update_spec: Specification of the new property values to set on the local library. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a local library. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``update_spec`` is not valid. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the :attr:`LibraryModel.version` of ``update_spec`` is not equal to the current version of the library. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.UpdateLocalLibrary``. """ return self._invoke('update', { 'library_id': library_id, 'update_spec': update_spec, })
[docs]class SubscribedLibrary(VapiInterface): """ """ def __init__(self, config): """ :type config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param config: Configuration to be used for creating the stub. """ VapiInterface.__init__(self, config, _SubscribedLibraryStub)
[docs] class ProbeResult(VapiStruct): """ The ``SubscribedLibrary.ProbeResult`` class defines the subscription information probe result. This describes whether using a given subscription URL is successful or if there are access problems, such as SSL errors. .. tip:: The arguments are used to initialize data attributes with the same names. """ def __init__(self, status=None, ssl_thumbprint=None, error_messages=None, ): """ :type status: :class:`SubscribedLibrary.ProbeResult.Status` :param status: The status of probe result. This will be one of SUCCESS, INVALID_URL, TIMED_OUT, HOST_NOT_FOUND, RESOURCE_NOT_FOUND, INVALID_CREDENTIALS, CERTIFICATE_ERROR, UNKNOWN_ERROR. :type ssl_thumbprint: :class:`str` or ``None`` :param ssl_thumbprint: The SSL thumbprint for the remote endpoint. An SSL thumbprint is only returned if the host is secured with SSL/TLS. :type error_messages: :class:`list` of :class:`com.vmware.vapi.std_client.LocalizableMessage` :param error_messages: If the probe result is in an error status, this attribute will contain the detailed error messages. """ self.status = status self.ssl_thumbprint = ssl_thumbprint self.error_messages = error_messages VapiStruct.__init__(self)
[docs] class Status(Enum): """ The ``SubscribedLibrary.ProbeResult.Status`` class defines the error status constants for the probe result. .. note:: This class represents an enumerated type in the interface language definition. The class contains class attributes which represent the values in the current version of the enumerated type. Newer versions of the enumerated type may contain new values. To use new values of the enumerated type in communication with a server that supports the newer version of the API, you instantiate this class. See :ref:`enumerated type description page <enumeration_description>`. """ SUCCESS = None """ Indicates that the probe was successful. """ INVALID_URL = None """ Indicates that the supplied URL was not valid. """ TIMED_OUT = None """ Indicates that the probe timed out while attempting to connect to the URL. """ HOST_NOT_FOUND = None """ Indicates that the host in the URL could not be found. """ RESOURCE_NOT_FOUND = None """ Indicates that the given resource at the URL was not found. """ INVALID_CREDENTIALS = None """ Indicates that the connection was rejected due to invalid credentials. """ CERTIFICATE_ERROR = None """ Indicates that the provided server certificate thumbprint in :attr:`com.vmware.content.library_client.SubscriptionInfo.ssl_thumbprint` is invalid. In this case, the returned null should be set in :attr:`com.vmware.content.library_client.SubscriptionInfo.ssl_thumbprint`. """ UNKNOWN_ERROR = None """ Indicates an unspecified error different from the other error cases defined in :class:`SubscribedLibrary.ProbeResult.Status`. """ def __init__(self, string): """ :type string: :class:`str` :param string: String value for the :class:`Status` instance. """ Enum.__init__(string)
Status._set_values([ Status('SUCCESS'), Status('INVALID_URL'), Status('TIMED_OUT'), Status('HOST_NOT_FOUND'), Status('RESOURCE_NOT_FOUND'), Status('INVALID_CREDENTIALS'), Status('CERTIFICATE_ERROR'), Status('UNKNOWN_ERROR'), ]) Status._set_binding_type(type.EnumType( 'com.vmware.content.subscribed_library.probe_result.status', Status))
ProbeResult._set_binding_type(type.StructType( 'com.vmware.content.subscribed_library.probe_result', { 'status': type.ReferenceType(sys.modules[__name__], 'SubscribedLibrary.ProbeResult.Status'), 'ssl_thumbprint': type.OptionalType(type.StringType()), 'error_messages': type.ListType(type.ReferenceType(com.vmware.vapi.std_client, 'LocalizableMessage')), }, ProbeResult, False, None))
[docs] def create(self, create_spec, client_token=None, ): """ Creates a new subscribed library. Once created, the subscribed library will be empty. If the :attr:`LibraryModel.subscription_info` property is set, the Content Library Service will attempt to synchronize to the remote source. This is an asynchronous operation so the content of the published library may not immediately appear. :type client_token: :class:`str` or ``None`` :param client_token: Unique token generated on the client for each creation request. The token should be a universally unique identifier (UUID), for example: ``b8a2a2e3-2314-43cd-a871-6ede0f429751``. This token can be used to guarantee idempotent creation. If not specified creation is not idempotent. :type create_spec: :class:`LibraryModel` :param create_spec: Specification for the new subscribed library. :rtype: :class:`str` :return: Identifier of the newly created subscribed library. The return value will be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``create_spec`` is not valid. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``client_token`` does not conform to the UUID format. :raise: :class:`com.vmware.vapi.std.errors_client.Unsupported` if using multiple storage backings. :raise: :class:`com.vmware.vapi.std.errors_client.ResourceInaccessible` if subscribing to a published library which cannot be accessed. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.CreateSubscribedLibrary``. """ return self._invoke('create', { 'client_token': client_token, 'create_spec': create_spec, })
[docs] def delete(self, library_id, ): """ Deletes the specified subscribed library. Deleting a subscribed library will remove the entry immediately and begin an asynchronous task to remove all cached content for the library. If the asynchronous task fails, file content may remain on the storage backing. This content will require manual removal. :type library_id: :class:`str` :param library_id: Identifier of the subscribed library to delete. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library referenced by ``library_id`` is not a subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library referenced by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.DeleteSubscribedLibrary``. """ return self._invoke('delete', { 'library_id': library_id, })
[docs] def evict(self, library_id, ): """ Evicts the cached content of an on-demand subscribed library. This method allows the cached content of a subscribed library to be removed to free up storage capacity. This method will only work when a subscribed library is synchronized on-demand. :type library_id: :class:`str` :param library_id: Identifier of the subscribed library whose content should be evicted. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.NotAllowedInCurrentState` if the library specified by ``library_id`` does not synchronize on-demand. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.EvictSubscribedLibrary``. """ return self._invoke('evict', { 'library_id': library_id, })
[docs] def get(self, library_id, ): """ Returns a given subscribed library. :type library_id: :class:`str` :param library_id: Identifier of the subscribed library to return. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :rtype: :class:`LibraryModel` :return: The :class:`LibraryModel` instance that corresponds to ``library_id``. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library associated with ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library associated with ``library_id`` is not a subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``System.Read``. """ return self._invoke('get', { 'library_id': library_id, })
[docs] def list(self): """ Returns the identifiers of all subscribed libraries in the Content Library. :rtype: :class:`list` of :class:`str` :return: The :class:`list` of identifiers of all subscribed libraries in the Content Library. The return value will contain identifiers for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``System.Read``. """ return self._invoke('list', None)
[docs] def sync(self, library_id, ): """ Forces the synchronization of the subscribed library. Synchronizing a subscribed library forcefully with this method will perform the same synchronization behavior as would run periodically for the library. The :attr:`com.vmware.content.library_client.SubscriptionInfo.on_demand` setting is respected. Calling this method on a library that is already in the process of synchronizing will have no effect. :type library_id: :class:`str` :param library_id: Identifier of the subscribed library to synchronize. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if some parameter in the subscribed library subscription info is invalid. :raise: :class:`com.vmware.vapi.std.errors_client.ResourceInaccessible` if the published library cannot be contacted or found. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.SyncLibrary``. """ return self._invoke('sync', { 'library_id': library_id, })
[docs] def update(self, library_id, update_spec, ): """ Updates the properties of a subscribed library. This is an incremental update to the subscribed library. Attributes that are None in the update specification will be left unchanged. :type library_id: :class:`str` :param library_id: Identifier of the subscribed library to update. The parameter must be an identifier for the resource type: ``com.vmware.content.Library``. :type update_spec: :class:`LibraryModel` :param update_spec: Specification of the new property values to set on the subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.NotFound` if the library specified by ``library_id`` does not exist. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidElementType` if the library specified by ``library_id`` is not a subscribed library. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the ``update_spec`` is not valid. :raise: :class:`com.vmware.vapi.std.errors_client.InvalidArgument` if the :attr:`LibraryModel.version` of ``update_spec`` is not equal to the current version of the library. :raise: :class:`com.vmware.vapi.std.errors_client.ResourceInaccessible` if the subscription info is being updated but the published library cannot be contacted or found. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * The resource ``com.vmware.content.Library`` referenced by the parameter ``library_id`` requires ``ContentLibrary.UpdateSubscribedLibrary``. """ return self._invoke('update', { 'library_id': library_id, 'update_spec': update_spec, })
[docs] def probe(self, subscription_info, ): """ Probes remote library subscription information, including URL, SSL certificate and password. The resulting :class:`SubscribedLibrary.ProbeResult` class describes whether or not the subscription configuration is successful. :type subscription_info: :class:`com.vmware.content.library_client.SubscriptionInfo` :param subscription_info: The subscription info to be probed. :rtype: :class:`SubscribedLibrary.ProbeResult` :return: The subscription info probe result. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.ProbeSubscription``. """ return self._invoke('probe', { 'subscription_info': subscription_info, })
[docs]class Type(VapiInterface): """ The ``Type`` class exposes the :class:`com.vmware.content.library_client.ItemModel` types that this Content Library Service supports. A library item has an optional type which can be specified with the :attr:`com.vmware.content.library_client.ItemModel.type` attribute. For items with a type that is supported by a plugin, the Content Library Service may understand the files which are part of the library item and can produce metadata for the item. In other cases, uploads may require a process in which one upload implies subsequent uploads. For example, an Open Virtualization Format (OVF) package is composed of an OVF descriptor file and the associated virtual disk files. Uploading an OVF descriptor can enable the Content Library Service to understand that the complete OVF package requires additional disk files, and it can set up the transfers for the disks automatically by adding the file entries for the disks when the OVF descriptor is uploaded. When a type is not supported by a plugin, or the type is not specified, the Content Library Service can handle a library item in a default way, without adding metadata to the item or guiding the upload process. """ def __init__(self, config): """ :type config: :class:`vmware.vapi.bindings.stub.StubConfiguration` :param config: Configuration to be used for creating the stub. """ VapiInterface.__init__(self, config, _TypeStub)
[docs] class Info(VapiStruct): """ The ``Type.Info`` class describes support for a specific type of data in an :class:`com.vmware.content.library_client.ItemModel`. The ``Type.Info`` can be queried through the :class:`Type` class. Type support describes plugins in the Content Library which can provide metadata on library items and help manage the transfer process by adding dependent files when a current file is added. .. tip:: The arguments are used to initialize data attributes with the same names. """ def __init__(self, description=None, name=None, type=None, vendor=None, version=None, ): """ :type description: :class:`str` :param description: A description of the type support offered by the plugin. :type name: :class:`str` :param name: The name of the plugin which provides the type support. :type type: :class:`str` :param type: The type which the plugin supports. To upload a library item of the type supported by the plugin, the :attr:`com.vmware.content.library_client.ItemModel.type` attribute of the item should be set to this value. :type vendor: :class:`str` :param vendor: The name of the vendor who created the type support plugin. :type version: :class:`str` :param version: The version number of the type support plugin. """ self.description = description self.name = name self.type = type self.vendor = vendor self.version = version VapiStruct.__init__(self)
Info._set_binding_type(type.StructType( 'com.vmware.content.type.info', { 'description': type.StringType(), 'name': type.StringType(), 'type': type.StringType(), 'vendor': type.StringType(), 'version': type.StringType(), }, Info, False, None))
[docs] def list(self): """ Returns a :class:`list` of :class:`Type.Info` instances which describe the type support plugins in this Content Library. :rtype: :class:`list` of :class:`Type.Info` :return: The :class:`list` of :class:`Type.Info` instances which describe the type support plugins in this Content Library. :raise: :class:`com.vmware.vapi.std.errors_client.Unauthorized` if you do not have all of the privileges described as follows: * Method execution requires ``ContentLibrary.TypeIntrospection``. """ return self._invoke('list', None)
class _ConfigurationStub(ApiInterfaceStub): def __init__(self, config): # properties for update operation update_input_type = type.StructType('operation-input', { 'model': type.ReferenceType(sys.modules[__name__], 'ConfigurationModel'), }) update_error_dict = { 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), } update_input_validator_list = [ ] update_output_validator_list = [ ] # properties for get operation get_input_type = type.StructType('operation-input', {}) get_error_dict = {} get_input_validator_list = [ ] get_output_validator_list = [ ] operations = { 'update': { 'input_type': update_input_type, 'output_type': type.VoidType(), 'errors': update_error_dict, 'input_validator_list': update_input_validator_list, 'output_validator_list': update_output_validator_list, }, 'get': { 'input_type': get_input_type, 'output_type': type.ReferenceType(sys.modules[__name__], 'ConfigurationModel'), 'errors': get_error_dict, 'input_validator_list': get_input_validator_list, 'output_validator_list': get_output_validator_list, }, } ApiInterfaceStub.__init__(self, iface_name='com.vmware.content.configuration', config=config, operations=operations) class _LibraryStub(ApiInterfaceStub): def __init__(self, config): # properties for get operation get_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) get_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), } get_input_validator_list = [ ] get_output_validator_list = [ ] # properties for list operation list_input_type = type.StructType('operation-input', {}) list_error_dict = {} list_input_validator_list = [ ] list_output_validator_list = [ ] # properties for find operation find_input_type = type.StructType('operation-input', { 'spec': type.ReferenceType(sys.modules[__name__], 'Library.FindSpec'), }) find_error_dict = { 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), } find_input_validator_list = [ ] find_output_validator_list = [ ] # properties for update operation update_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), 'update_spec': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), }) update_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), } update_input_validator_list = [ ] update_output_validator_list = [ ] operations = { 'get': { 'input_type': get_input_type, 'output_type': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), 'errors': get_error_dict, 'input_validator_list': get_input_validator_list, 'output_validator_list': get_output_validator_list, }, 'list': { 'input_type': list_input_type, 'output_type': type.ListType(type.IdType()), 'errors': list_error_dict, 'input_validator_list': list_input_validator_list, 'output_validator_list': list_output_validator_list, }, 'find': { 'input_type': find_input_type, 'output_type': type.ListType(type.IdType()), 'errors': find_error_dict, 'input_validator_list': find_input_validator_list, 'output_validator_list': find_output_validator_list, }, 'update': { 'input_type': update_input_type, 'output_type': type.VoidType(), 'errors': update_error_dict, 'input_validator_list': update_input_validator_list, 'output_validator_list': update_output_validator_list, }, } ApiInterfaceStub.__init__(self, iface_name='com.vmware.content.library', config=config, operations=operations) class _LocalLibraryStub(ApiInterfaceStub): def __init__(self, config): # properties for create operation create_input_type = type.StructType('operation-input', { 'client_token': type.OptionalType(type.StringType()), 'create_spec': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), }) create_error_dict = { 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), 'com.vmware.vapi.std.errors.unsupported': type.ReferenceType(com.vmware.vapi.std.errors_client, 'Unsupported'), } create_input_validator_list = [ ] create_output_validator_list = [ ] # properties for delete operation delete_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) delete_error_dict = { 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), } delete_input_validator_list = [ ] delete_output_validator_list = [ ] # properties for get operation get_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) get_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), } get_input_validator_list = [ ] get_output_validator_list = [ ] # properties for list operation list_input_type = type.StructType('operation-input', {}) list_error_dict = {} list_input_validator_list = [ ] list_output_validator_list = [ ] # properties for update operation update_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), 'update_spec': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), }) update_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), } update_input_validator_list = [ ] update_output_validator_list = [ ] operations = { 'create': { 'input_type': create_input_type, 'output_type': type.IdType(resource_types='com.vmware.content.Library'), 'errors': create_error_dict, 'input_validator_list': create_input_validator_list, 'output_validator_list': create_output_validator_list, }, 'delete': { 'input_type': delete_input_type, 'output_type': type.VoidType(), 'errors': delete_error_dict, 'input_validator_list': delete_input_validator_list, 'output_validator_list': delete_output_validator_list, }, 'get': { 'input_type': get_input_type, 'output_type': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), 'errors': get_error_dict, 'input_validator_list': get_input_validator_list, 'output_validator_list': get_output_validator_list, }, 'list': { 'input_type': list_input_type, 'output_type': type.ListType(type.IdType()), 'errors': list_error_dict, 'input_validator_list': list_input_validator_list, 'output_validator_list': list_output_validator_list, }, 'update': { 'input_type': update_input_type, 'output_type': type.VoidType(), 'errors': update_error_dict, 'input_validator_list': update_input_validator_list, 'output_validator_list': update_output_validator_list, }, } ApiInterfaceStub.__init__(self, iface_name='com.vmware.content.local_library', config=config, operations=operations) class _SubscribedLibraryStub(ApiInterfaceStub): def __init__(self, config): # properties for create operation create_input_type = type.StructType('operation-input', { 'client_token': type.OptionalType(type.StringType()), 'create_spec': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), }) create_error_dict = { 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), 'com.vmware.vapi.std.errors.unsupported': type.ReferenceType(com.vmware.vapi.std.errors_client, 'Unsupported'), 'com.vmware.vapi.std.errors.resource_inaccessible': type.ReferenceType(com.vmware.vapi.std.errors_client, 'ResourceInaccessible'), } create_input_validator_list = [ ] create_output_validator_list = [ ] # properties for delete operation delete_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) delete_error_dict = { 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), } delete_input_validator_list = [ ] delete_output_validator_list = [ ] # properties for evict operation evict_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) evict_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.not_allowed_in_current_state': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotAllowedInCurrentState'), } evict_input_validator_list = [ ] evict_output_validator_list = [ ] # properties for get operation get_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) get_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), } get_input_validator_list = [ ] get_output_validator_list = [ ] # properties for list operation list_input_type = type.StructType('operation-input', {}) list_error_dict = {} list_input_validator_list = [ ] list_output_validator_list = [ ] # properties for sync operation sync_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), }) sync_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), 'com.vmware.vapi.std.errors.resource_inaccessible': type.ReferenceType(com.vmware.vapi.std.errors_client, 'ResourceInaccessible'), } sync_input_validator_list = [ ] sync_output_validator_list = [ ] # properties for update operation update_input_type = type.StructType('operation-input', { 'library_id': type.IdType(resource_types='com.vmware.content.Library'), 'update_spec': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), }) update_error_dict = { 'com.vmware.vapi.std.errors.not_found': type.ReferenceType(com.vmware.vapi.std.errors_client, 'NotFound'), 'com.vmware.vapi.std.errors.invalid_element_type': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidElementType'), 'com.vmware.vapi.std.errors.invalid_argument': type.ReferenceType(com.vmware.vapi.std.errors_client, 'InvalidArgument'), 'com.vmware.vapi.std.errors.resource_inaccessible': type.ReferenceType(com.vmware.vapi.std.errors_client, 'ResourceInaccessible'), } update_input_validator_list = [ ] update_output_validator_list = [ ] # properties for probe operation probe_input_type = type.StructType('operation-input', { 'subscription_info': type.ReferenceType(com.vmware.content.library_client, 'SubscriptionInfo'), }) probe_error_dict = {} probe_input_validator_list = [ ] probe_output_validator_list = [ ] operations = { 'create': { 'input_type': create_input_type, 'output_type': type.IdType(resource_types='com.vmware.content.Library'), 'errors': create_error_dict, 'input_validator_list': create_input_validator_list, 'output_validator_list': create_output_validator_list, }, 'delete': { 'input_type': delete_input_type, 'output_type': type.VoidType(), 'errors': delete_error_dict, 'input_validator_list': delete_input_validator_list, 'output_validator_list': delete_output_validator_list, }, 'evict': { 'input_type': evict_input_type, 'output_type': type.VoidType(), 'errors': evict_error_dict, 'input_validator_list': evict_input_validator_list, 'output_validator_list': evict_output_validator_list, }, 'get': { 'input_type': get_input_type, 'output_type': type.ReferenceType(sys.modules[__name__], 'LibraryModel'), 'errors': get_error_dict, 'input_validator_list': get_input_validator_list, 'output_validator_list': get_output_validator_list, }, 'list': { 'input_type': list_input_type, 'output_type': type.ListType(type.IdType()), 'errors': list_error_dict, 'input_validator_list': list_input_validator_list, 'output_validator_list': list_output_validator_list, }, 'sync': { 'input_type': sync_input_type, 'output_type': type.VoidType(), 'errors': sync_error_dict, 'input_validator_list': sync_input_validator_list, 'output_validator_list': sync_output_validator_list, }, 'update': { 'input_type': update_input_type, 'output_type': type.VoidType(), 'errors': update_error_dict, 'input_validator_list': update_input_validator_list, 'output_validator_list': update_output_validator_list, }, 'probe': { 'input_type': probe_input_type, 'output_type': type.ReferenceType(sys.modules[__name__], 'SubscribedLibrary.ProbeResult'), 'errors': probe_error_dict, 'input_validator_list': probe_input_validator_list, 'output_validator_list': probe_output_validator_list, }, } ApiInterfaceStub.__init__(self, iface_name='com.vmware.content.subscribed_library', config=config, operations=operations) class _TypeStub(ApiInterfaceStub): def __init__(self, config): # properties for list operation list_input_type = type.StructType('operation-input', {}) list_error_dict = {} list_input_validator_list = [ ] list_output_validator_list = [ ] operations = { 'list': { 'input_type': list_input_type, 'output_type': type.ListType(type.ReferenceType(sys.modules[__name__], 'Type.Info')), 'errors': list_error_dict, 'input_validator_list': list_input_validator_list, 'output_validator_list': list_output_validator_list, }, } ApiInterfaceStub.__init__(self, iface_name='com.vmware.content.type', config=config, operations=operations)