def __init__( self, id=None, default_message=None, args=None, params=None, localized=None, ): """ :type id: :class:`str` :param id: Unique identifier of the localizable string or message template. This identifier is typically used to retrieve a locale-specific string or message template from a message catalog. :type default_message: :class:`str` :param default_message: The value of this localizable string or message template in the ``en_US`` (English) locale. If :attr:`LocalizableMessage.id` refers to a message template, the default message will contain the substituted arguments. This value can be used by clients that do not need to display strings and messages in the native language of the user. It could also be used as a fallback if a client is unable to access the appropriate message catalog. :type args: :class:`list` of :class:`str` :param args: Positional arguments to be substituted into the message template. This list will be empty if the message uses named arguments or has no arguments. :type params: (:class:`dict` of :class:`str` and :class:`LocalizationParam`) or ``None`` :param params: Named arguments to be substituted into the message template. **Warning:** This attribute is part of a new feature in development. It may be changed at any time and may not have all supported functionality implemented. None means that the message template requires no arguments or positional arguments are used. :type localized: :class:`str` or ``None`` :param localized: Localized string value as per request requirements. **Warning:** This attribute is part of a new feature in development. It may be changed at any time and may not have all supported functionality implemented. when the client has not requested specific locale the implementation may not populate this field to conserve resources. """ self.id = id self.default_message = default_message self.args = args self.params = params self.localized = localized VapiStruct.__init__(self)
def __init__( self, name=None, config_status=None, scope=None, creation_time=None, update_time=None, access_url=None, message=None, ): """ :type name: :class:`str` :param name: Name of the Harbor project. Should be between 2-63 characters long alphanumeric string and may contain the following characters: a-z,0-9, and '-'. Must be starting with characters or numbers, with the '-' character allowed anywhere except the first or last character. :type config_status: :class:`Projects.ConfigStatus` :param config_status: The status of the Harbor project. :type scope: :class:`Projects.Scope` :param scope: The access type of a Harbor project. :type creation_time: :class:`datetime.datetime` :param creation_time: The date and time when the harbor project creation API was triggered and project identifier generated. :type update_time: :class:`datetime.datetime` :param update_time: The date and time when the harbor project purge API was triggered. In case no purge was triggered, ``updateTime`` is same as ``creationTime``. This attribute is optional and it is only relevant when the value of ``configStatus`` is :attr:`Projects.ConfigStatus.READY`. :type access_url: :class:`str` :param access_url: URL to access the harbor project through docker client. This attribute is optional and it is only relevant when the value of ``configStatus`` is :attr:`Projects.ConfigStatus.READY`. :type message: :class:`com.vmware.vapi.std_client.LocalizableMessage` :param message: Details about the ERROR project status. This attribute is optional and it is only relevant when the value of ``configStatus`` is :attr:`Projects.ConfigStatus.ERROR`. """ self.name = name self.config_status = config_status self.scope = scope self.creation_time = creation_time self.update_time = update_time self.access_url = access_url self.message = message VapiStruct.__init__(self)
def __init__( self, failure_action=None, pre_remediation_power_action=None, enable_quick_boot=None, disable_dpm=None, disable_hac=None, evacuate_offline_vms=None, enforce_hcl_validation=None, ): """ :type failure_action: :class:`Apply.FailureAction` or ``None`` :param failure_action: What action is to be taken if entering maintenance mode fails on a given host of the cluster. If None, configured value would be unset. :type pre_remediation_power_action: :class:`Apply.ConfiguredPolicySpec.PreRemediationPowerAction` or ``None`` :param pre_remediation_power_action: Specifies what should be done to the power state of the VM before entering maintenance mode. If None, configured value would be unset. :type enable_quick_boot: :class:`bool` or ``None`` :param enable_quick_boot: Enable Quick Boot during remediation in the cluster. If None, configured value would be unset. :type disable_dpm: :class:`bool` or ``None`` :param disable_dpm: Disable DPM on the cluster. If None, configured value would be unset. :type disable_hac: :class:`bool` or ``None`` :param disable_hac: Disable HA Admission control on the cluster. If None, configured value would be unset. :type evacuate_offline_vms: :class:`bool` or ``None`` :param evacuate_offline_vms: Evacuate powered off/suspended VMs when attempting maintenance mode. If None, configured value would be unset. :type enforce_hcl_validation: :class:`bool` or ``None`` :param enforce_hcl_validation: Enforce Hcl validation, when applicable, to prevent remediation if hardware compatibility issues are found. This attribute was added in vSphere API 7.0.1.0. If None, hardware compatibility issues will not prevent remediation. """ self.failure_action = failure_action self.pre_remediation_power_action = pre_remediation_power_action self.enable_quick_boot = enable_quick_boot self.disable_dpm = disable_dpm self.disable_hac = disable_hac self.evacuate_offline_vms = evacuate_offline_vms self.enforce_hcl_validation = enforce_hcl_validation VapiStruct.__init__(self)
def __init__( self, special_chars=None, alpha_chars=None, uppercase_chars=None, lowercase_chars=None, numeric_chars=None, adj_identical_chars=None, password_reuse=None, max_life=None, max_length=None, min_length=None, ): """ :type special_chars: :class:`long` :param special_chars: Minimum special characters. :type alpha_chars: :class:`long` :param alpha_chars: Minimum alphabetic characters. :type uppercase_chars: :class:`long` :param uppercase_chars: Minimum uppercase characters. :type lowercase_chars: :class:`long` :param lowercase_chars: Minimum lowercase characters. :type numeric_chars: :class:`long` :param numeric_chars: Minimum numeric characters. :type adj_identical_chars: :class:`long` :param adj_identical_chars: Maximum adjacent identical characters. :type password_reuse: :class:`long` :param password_reuse: Previous password reuse restriction. :type max_life: :class:`long` :param max_life: Maximum lifetime. :type max_length: :class:`long` :param max_length: Maximum length. :type min_length: :class:`long` :param min_length: Minimum length. """ self.special_chars = special_chars self.alpha_chars = alpha_chars self.uppercase_chars = uppercase_chars self.lowercase_chars = lowercase_chars self.numeric_chars = numeric_chars self.adj_identical_chars = adj_identical_chars self.password_reuse = password_reuse self.max_life = max_life self.max_length = max_length self.min_length = min_length VapiStruct.__init__(self)
def __init__( self, ssl_thumbprint=None, ): """ :type ssl_thumbprint: :class:`str` :param ssl_thumbprint: The SHA-256 thumbprint of the SSL certificate for the destination PSC endpoint. **Warning:** This attribute is available as Technology Preview. These are early access APIs provided to test, automate and provide feedback on the feature. Since this can change based on feedback, VMware does not guarantee backwards compatibility and recommends against using them in production environments. Some Technology Preview APIs might only be applicable to specific environments. """ self.ssl_thumbprint = ssl_thumbprint VapiStruct.__init__(self)
def __init__( self, configurable=None, mode=None, address=None, prefix=None, default_gateway=None, ): """ :type configurable: :class:`bool` :param configurable: The specified network interface is configurable or not. This attribute was added in vSphere API 6.7. :type mode: :class:`Ipv4.Mode` :param mode: The Address assignment mode. This attribute was added in vSphere API 6.7. :type address: :class:`str` :param address: The IPv4 address, for example, "10.20.80.191". This attribute was added in vSphere API 6.7. This attribute is optional and it is only relevant when the value of ``mode`` is one of :attr:`Ipv4.Mode.STATIC` or :attr:`Ipv4.Mode.DHCP`. :type prefix: :class:`long` :param prefix: The IPv4 CIDR prefix, for example, 24. See http://www.oav.net/mirrors/cidr.html for netmask-to-prefix conversion. This attribute was added in vSphere API 6.7. This attribute is optional and it is only relevant when the value of ``mode`` is one of :attr:`Ipv4.Mode.STATIC` or :attr:`Ipv4.Mode.DHCP`. :type default_gateway: :class:`str` :param default_gateway: The IPv4 address of the default gateway. This configures the global default gateway on the appliance with the specified gateway address and interface. This gateway replaces the existing default gateway configured on the appliance. However, if the gateway address is link-local, then it is added for that interface. This does not support configuration of multiple global default gateways through different interfaces. This attribute was added in vSphere API 6.7. This attribute is optional and it is only relevant when the value of ``mode`` is one of :attr:`Ipv4.Mode.STATIC` or :attr:`Ipv4.Mode.DHCP`. """ self.configurable = configurable self.mode = mode self.address = address self.prefix = prefix self.default_gateway = default_gateway VapiStruct.__init__(self)
def __init__( self, ip_addresses=None, dhcp=None, ): """ :type ip_addresses: :class:`list` of :class:`Interfaces.IpAddressInfo` :param ip_addresses: IP addresses configured on the interface. This attribute was added in vSphere API 7.0.0.0. :type dhcp: :class:`com.vmware.vcenter.vm.guest_client.DhcpConfigInfo` or ``None`` :param dhcp: Client side DHCP for an interface. This attribute was added in vSphere API 7.0.0.0. If None the IP was not configured by DHCP. """ self.ip_addresses = ip_addresses self.dhcp = dhcp VapiStruct.__init__(self)
def __init__( self, hostname=None, port=None, ): """ :type hostname: :class:`str` :param hostname: The IP address or DNS resolvable name of the service. This attribute was added in vSphere API 7.0.0.0. :type port: :class:`long` or ``None`` :param port: The port of the service. This attribute was added in vSphere API 7.0.0.0. If None, port 443 will be used. """ self.hostname = hostname self.port = port VapiStruct.__init__(self)
def __init__( self, identity=None, description=None, service_id=None, operation_id=None, options=None, formatter=None, output_field_list=None, ): """ :type identity: :class:`Command.Identity` :param identity: Basic command identity. :type description: :class:`str` :param description: The text description displayed to the user in help output. :type service_id: :class:`str` :param service_id: The service identifier that contains the operations for this CLI command. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``com.vmware.vapi.service``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``com.vmware.vapi.service``. :type operation_id: :class:`str` :param operation_id: The operation identifier corresponding to this CLI command. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``com.vmware.vapi.operation``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``com.vmware.vapi.operation``. :type options: :class:`list` of :class:`Command.OptionInfo` :param options: The input for this command. :type formatter: :class:`Command.FormatterType` or ``None`` :param formatter: The formatter to use when displaying the output of this command. If not present, client can choose a default output formatter. :type output_field_list: :class:`list` of :class:`Command.OutputInfo` :param output_field_list: List of output structure name and output field info. """ self.identity = identity self.description = description self.service_id = service_id self.operation_id = operation_id self.options = options self.formatter = formatter self.output_field_list = output_field_list VapiStruct.__init__(self)
def __init__( self, user_name=None, password=None, ): """ :type user_name: :class:`str` :param user_name: Name of the user to authenticate. **Warning:** This attribute is available as technical preview. It may be changed in a future release. :type password: :class:`str` :param password: Password for the user. **Warning:** This attribute is available as technical preview. It may be changed in a future release. """ self.user_name = user_name self.password = password VapiStruct.__init__(self)
def __init__( self, status=None, ): """ :type status: :class:`com.vmware.vcenter.compute.policies_client.ObjectCompliance` :param status: The compliance status of the policy on a specified object.**Warning:** This attribute is available as Technology Preview. These are early access APIs provided to test, automate and provide feedback on the feature. Since this can change based on feedback, VMware does not guarantee backwards compatibility and recommends against using them in production environments. Some Technology Preview APIs might only be applicable to specific environments. """ self.status = status VapiStruct.__init__(self)
def visit_dynamic_struct(self, typ): """ Visit StructValue to convert it into the base VapiStruct :type typ: :class:`vmware.vapi.bindings.type.DynamicStructType` :param typ: Binding type of the value """ self._out_value = VapiStruct(struct_value=self._in_value)
def __init__( self, mode=None, servers=None, ): """ :type mode: :class:`Servers.DNSServerMode` :param mode: Define how to determine the DNS servers. Leave the servers argument empty if the mode argument is "DHCP". Set the servers argument to a comma-separated list of DNS servers if the mode argument is "static". The DNS server are assigned from the specified list. :type servers: :class:`list` of :class:`str` :param servers: List of the currently used DNS servers. """ self.mode = mode self.servers = servers VapiStruct.__init__(self)
def __init__( self, backup_password=None, location_type=None, location=None, location_user=None, location_password=None, sso_admin_user_name=None, sso_admin_user_password=None, ): """ :type backup_password: :class:`str` or ``None`` :param backup_password: a password for a backup piece backupPassword If no password then the piece will not be decrypted :type location_type: :class:`Restore.LocationType` :param location_type: a type of location :type location: :class:`str` :param location: path or url :type location_user: :class:`str` or ``None`` :param location_user: username for location locationUser User name for this location if login is required. :type location_password: :class:`str` or ``None`` :param location_password: password for location locationPassword Password for the specified user if login is required at this location. :type sso_admin_user_name: :class:`str` or ``None`` :param sso_admin_user_name: Administrators username for SSO. This attribute was added in vSphere API 6.7. If None SSO authentication will not be used. If the vCenter Server is a management node or an embedded node, authentication is required. :type sso_admin_user_password: :class:`str` or ``None`` :param sso_admin_user_password: The password for SSO admin user. This attribute was added in vSphere API 6.7. If None SSO authentication will not be used. If the vCenter Server is a management node or an embedded node, authentication is required. """ self.backup_password = backup_password self.location_type = location_type self.location = location self.location_user = location_user self.location_password = location_password self.sso_admin_user_name = sso_admin_user_name self.sso_admin_user_password = sso_admin_user_password VapiStruct.__init__(self)
def __init__(self, identity=None, description=None, children=None, ): """ :type identity: :class:`Namespace.Identity` :param identity: Basic namespace identity. :type description: :class:`str` :param description: The text description displayed to the user in help output. :type children: :class:`list` of :class:`Namespace.Identity` :param children: The children of this namespace in the tree of CLI namespaces. """ self.identity = identity self.description = description self.children = children VapiStruct.__init__(self)
def __init__( self, current_url=None, default_url=None, check_updates=None, time=None, day=None, latest_update_install_time=None, latest_update_query_time=None, username=None, password=None, ): """ :type current_url: :class:`str` :param current_url: Current appliance update repository URL. :type default_url: :class:`str` :param default_url: Default appliance update repository URL. :type check_updates: :class:`Update.AutoUpdateNotification` :param check_updates: Check for update at the pre-configured repository URL. :type time: :class:`str` :param time: time to query for updates Format: HH:MM:SS Military (24 hour) Time Format :type day: :class:`Update.UpdateDay` :param day: day to query for updates :type latest_update_install_time: :class:`str` :param latest_update_install_time: timestamp of latest update installation :type latest_update_query_time: :class:`str` :param latest_update_query_time: timestamp of latest query to update repository :type username: :class:`str` :param username: username for the url update repository :type password: :class:`str` :param password: password for the url update repository """ self.current_url = current_url self.default_url = default_url self.check_updates = check_updates self.time = time self.day = day self.latest_update_install_time = latest_update_install_time self.latest_update_query_time = latest_update_query_time self.username = username self.password = password VapiStruct.__init__(self, { 'current_URL': 'current_url', 'default_URL': 'default_url', })
def __init__( self, valid=None, errors=None, ): """ :type valid: :class:`bool` :param valid: This boolean flag indicates whether the configuration document validated successfully with no validation errors. :type errors: :class:`list` of :class:`ValidationError` or ``None`` :param errors: Lists all validation errors identified in the configuration document. This is set when :attr:`ValidationResult.valid` is false. """ self.valid = valid self.errors = errors VapiStruct.__init__(self)
def __init__( self, display_name=None, vendor=None, display_version=None, summary=None, description=None, category=None, kb=None, release_date=None, components=None, removed_components=None, ): """ :type display_name: :class:`str` :param display_name: Display name of the OEM add-on. :type vendor: :class:`str` :param vendor: Vendor of the OEM add-on. :type display_version: :class:`str` :param display_version: Human readable version of the OEM add-on. :type summary: :class:`str` :param summary: Summary of the OEM add-on. :type description: :class:`str` :param description: Discription of the OEM add-on. :type category: :class:`Versions.CategoryType` :param category: Category of the OEM add-on. :type kb: :class:`str` :param kb: Link to kb article related to this the OEM add-on. :type release_date: :class:`datetime.datetime` :param release_date: Release date of the OEM add-on. :type components: :class:`list` of :class:`Versions.ComponentInfo` :param components: List of components in this OEM add-on. :type removed_components: :class:`list` of :class:`Versions.RemovedComponentInfo` :param removed_components: List of components removed by this OEM add-on. """ self.display_name = display_name self.vendor = vendor self.display_version = display_version self.summary = summary self.description = description self.category = category self.kb = kb self.release_date = release_date self.components = components self.removed_components = removed_components VapiStruct.__init__(self)
def __init__( self, cluster=None, cluster_name=None, current_version=None, available_versions=None, last_upgraded_date=None, desired_version=None, state=None, ): """ :type cluster: :class:`str` :param cluster: Identifier for the cluster. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``ClusterComputeResource``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``ClusterComputeResource``. :type cluster_name: :class:`str` :param cluster_name: Name of the cluster. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``ClusterComputeResource.name``. When methods return a value of this class as a return value, the attribute will be an identifier for the resource type: ``ClusterComputeResource.name``. :type current_version: :class:`str` :param current_version: Current version of the cluster. :type available_versions: :class:`list` of :class:`str` :param available_versions: Set of versions available for upgrade. :type last_upgraded_date: :class:`datetime.datetime` or ``None`` :param last_upgraded_date: Date of last successful upgrade. If None, the cluster has not yet been upgraded. :type desired_version: :class:`str` or ``None`` :param desired_version: Desired version the cluster will be upgraded to. If None, the cluster upgrade is not in progress. :type state: :class:`Clusters.State` :param state: Current state of the upgrade. """ self.cluster = cluster self.cluster_name = cluster_name self.current_version = current_version self.available_versions = available_versions self.last_upgraded_date = last_upgraded_date self.desired_version = desired_version self.state = state VapiStruct.__init__(self)
def __init__( self, address=None, https_port=None, ): """ :type address: :class:`str` :param address: The IP address or DNS resolvable name of the remote PSC. This attribute was added in vSphere API 6.7. :type https_port: :class:`long` or ``None`` :param https_port: The HTTPS port of the remote PSC. This attribute was added in vSphere API 6.7. If None, port 443 will be used. """ self.address = address self.https_port = https_port VapiStruct.__init__(self)
def __init__( self, provider=None, ): """ :type provider: :class:`str` :param provider: Sync provider id. **Warning:** This attribute is available as technical preview. It may be changed in a future release. When clients pass a value of this class as a parameter, the attribute must be an identifier for the resource type: ``com.vmware.vcenter.hvc.links.sync.Providers``. 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.hvc.links.sync.Providers``. """ self.provider = provider VapiStruct.__init__(self)
def __init__(self, display_name=None, vendor=None, display_version=None, summary=None, description=None, category=None, urgency=None, kb=None, contact=None, release_date=None, ): """ :type display_name: :class:`str` :param display_name: Display name of the component. :type vendor: :class:`str` :param vendor: Vendor of the component. :type display_version: :class:`str` :param display_version: Human readable version of the component. :type summary: :class:`str` :param summary: Summary of the component version. :type description: :class:`str` :param description: Discription of the component version. :type category: :class:`Versions.CategoryType` :param category: Category of the component version. :type urgency: :class:`Versions.UrgencyType` :param urgency: Urgency of the component version. :type kb: :class:`str` :param kb: Link to kb article related to this the component version. :type contact: :class:`str` :param contact: Contact email for the component version. :type release_date: :class:`datetime.datetime` :param release_date: Release date of the component version. """ self.display_name = display_name self.vendor = vendor self.display_version = display_version self.summary = summary self.description = description self.category = category self.urgency = urgency self.kb = kb self.contact = contact self.release_date = release_date VapiStruct.__init__(self)
def __init__( self, stage=None, completed_work=None, total_work=None, completion_time=None, start_time=None, exception=None, ): """ :type stage: :class:`Providers.SessionInfo.Stage` :param stage: Sync stage for the session. **Warning:** This attribute is available as technical preview. It may be changed in a future release. :type completed_work: :class:`long` :param completed_work: Completed work for the session. **Warning:** This attribute is available as technical preview. It may be changed in a future release. :type total_work: :class:`long` :param total_work: Total work for the session. **Warning:** This attribute is available as technical preview. It may be changed in a future release. :type completion_time: :class:`datetime.datetime` :param completion_time: Time at which forced sync session was completed. **Warning:** This attribute is available as technical preview. It may be changed in a future release. If None there is an ongoing sync that has not completed :type start_time: :class:`datetime.datetime` :param start_time: Time at which force sync was initiated. **Warning:** This attribute is available as technical preview. It may be changed in a future release. :type exception: :class:`com.vmware.vapi.std_client.LocalizableMessage` :param exception: Exception message if there is a sync failure on forced sync. **Warning:** This attribute is available as technical preview. It may be changed in a future release. This attribute is optional and it is only relevant when the value of ``stage`` is :attr:`Providers.SessionInfo.Stage.FAILED`. """ self.stage = stage self.completed_work = completed_work self.total_work = total_work self.completion_time = completion_time self.start_time = start_time self.exception = exception VapiStruct.__init__(self)
def __init__( self, base_image=None, add_on=None, components=None, solutions=None, hardware_support=None, ): """ :type base_image: :class:`BaseImageInfo` :param base_image: Base image of the ESX. :type add_on: :class:`AddOnInfo` or ``None`` :param add_on: OEM customization on top of given base-image. The components in this customization override the components in the base base-image. If None, no OEM customization exists. :type components: :class:`dict` of :class:`str` and (:class:`ComponentInfo` or ``None``) :param components: Map of components in an ESX image. The key is the component name and value is the information about specific version of the component. When clients pass a value of this class as a parameter, the key in the attribute :class:`dict` must be an identifier for the resource type: ``com.vmware.esx.hosts.component``. When methods return a value of this class as a return value, the key in the attribute :class:`dict` will be an identifier for the resource type: ``com.vmware.esx.hosts.component``. :type solutions: :class:`dict` of :class:`str` and :class:`SolutionInfo` :param solutions: Map of software solutions in an ESX image. The key is the solution name and value is the specification detailing components registered by that solution. When clients pass a value of this class as a parameter, the key in the attribute :class:`dict` must be an identifier for the resource type: ``com.vmware.esx.hosts.solution``. When methods return a value of this class as a return value, the key in the attribute :class:`dict` will be an identifier for the resource type: ``com.vmware.esx.hosts.solution``. :type hardware_support: :class:`HardwareSupportInfo` or ``None`` :param hardware_support: Information about the Hardware Support Packages (HSP) configured. If None, no Hardware Support Package (HSP) info exists. """ self.base_image = base_image self.add_on = add_on self.components = components self.solutions = solutions self.hardware_support = hardware_support VapiStruct.__init__(self)
def __init__( self, parts=None, backup_password=None, location_type=None, location=None, location_user=None, location_password=None, comment=None, ): """ :type parts: :class:`list` of :class:`str` :param parts: a list of optional parts. Run backup parts APIs to get list of optional parts and description :type backup_password: :class:`str` or ``None`` :param backup_password: a password for a backup piece The backupPassword must adhere to the following password requirements: At least 8 characters, cannot be more than 20 characters in length. At least 1 uppercase letter. At least 1 lowercase letter. At least 1 numeric digit. At least 1 special character (i.e. any character not in [0-9,a-z,A-Z]). Only visible ASCII characters (for example, no space). backupPassword If no password then the piece will not be encrypted :type location_type: :class:`Backup.LocationType` :param location_type: a type of location :type location: :class:`str` :param location: path or url :type location_user: :class:`str` or ``None`` :param location_user: username for location locationUser User name for this location if login is required. :type location_password: :class:`str` or ``None`` :param location_password: password for location locationPassword Password for the specified user if login is required at this location. :type comment: :class:`str` or ``None`` :param comment: Custom comment comment an optional comment """ self.parts = parts self.backup_password = backup_password self.location_type = location_type self.location = location self.location_user = location_user self.location_password = location_password self.comment = comment VapiStruct.__init__(self)
def __init__(self, total=None, completed=None, message=None, ): """ :type total: :class:`long` :param total: Total amount of the work for the operation. :type completed: :class:`long` :param completed: The amount of work completed for the operation. The value can only be incremented. :type message: :class:`com.vmware.vapi.std_client.LocalizableMessage` :param message: Message about the work progress. """ self.total = total self.completed = completed self.message = message VapiStruct.__init__(self)
def __init__( self, id=None, default_message=None, args=None, ): """ :type id: :class:`str` :param id: id in message bundle :type default_message: :class:`str` :param default_message: text in english :type args: :class:`list` of :class:`str` :param args: nested data """ self.id = id self.default_message = default_message self.args = args VapiStruct.__init__(self)
def __init__( self, dns_values=None, dns=None, ): """ :type dns_values: :class:`DnsAssignedValues` or ``None`` :param dns_values: Client DNS values. Data assigned by DNS. This attribute was added in vSphere API 7.0.0. If None no DNS assigned value exists. :type dns: :class:`DnsConfigInfo` or ``None`` :param dns: Client DNS configuration. How DNS queries are resolved. This attribute was added in vSphere API 7.0.0. If None no DNS assigned value exists. """ self.dns_values = dns_values self.dns = dns VapiStruct.__init__(self)
def __init__(self, packages=None, ): """ :type packages: :class:`dict` of :class:`str` and :class:`PackageInfo` :param packages: Routing information of all the vAPI packages. The key in the map is the ID of the package and the value in the map is the routing information for the package For an explanation of routing information within packages, see :class:`Package` When clients pass a value of this class as a parameter, the key in the attribute :class:`dict` must be an identifier for the resource type: ``com.vmware.vapi.package``. When methods return a value of this class as a return value, the key in the attribute :class:`dict` will be an identifier for the resource type: ``com.vmware.vapi.package``. """ self.packages = packages VapiStruct.__init__(self)
def __init__(self, policies=None, ): """ :type policies: :class:`set` of :class:`str` or ``None`` :param policies: Identifiers of storage policies that can match the filter. This attribute was added in vSphere API 6.7. When clients pass a value of this class as a parameter, the attribute must contain identifiers for the resource type: ``com.vmware.vcenter.StoragePolicy``. When methods return a value of this class as a return value, the attribute will contain identifiers for the resource type: ``com.vmware.vcenter.StoragePolicy``. If None or empty, storage policies with any identifiers match the filter. """ self.policies = policies VapiStruct.__init__(self)