Class List Method List File List

# Class: Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo

Inherits:
  VAPI::Bindings::VapiStruct
  - Object
  - VAPI::Bindings::VapiStruct
  - Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo
  show all
Defined in:
  /build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb

## Overview

The ``Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo`` class describes the authentication information. Authentication information could be specified for a package element, service elenent or an operation element.

     Using the authentication scheme information, a client invoking an API call from any  class  can figure out what kind of credentials are needed for that API call.

## Defined Under Namespace

Classes: SchemeType

## Instance Attribute Summary (collapse)

- - (String) scheme

  String identifier of the authentication scheme.

- - (Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType) scheme_type

  The type of the authentication scheme.

- - (String) session_manager

  In a session aware authentication scheme, a session manager is required that supports ``create`` , ``delete`` and ``keepAlive`` methods .

## Class Method Summary (collapse)

- + (VAPI::Bindings::StructType) binding_type

  Holds (gets or creates) the binding type metadata for this structure type.

## Instance Method Summary (collapse)

- - (AuthenticationInfo) initialize(ruby_values = nil, struct_value = nil) constructor

  Constructs a new instance.

## Constructor Details

### - (`AuthenticationInfo`) initialize(ruby_values = nil, struct_value = nil)

Constructs a new instance.

Parameters:

- ruby_values (`Hash`) (defaults to: `nil`) —

  a map of initial property values (optional)

- struct_value (`VAPI::Data::StructValue`) (defaults to: `nil`) —

  a raw StructValue from the wire (optional)

    621
    622
    623
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb', line 621

    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end

## Instance Attribute Details

### - (`String`) scheme

String identifier of the authentication scheme.

     Following are the supported authentication schemes by the infrastructure:

      * The identifier  ``com.vmware.vapi.std.security.saml_hok_token``  for SAML holder of key token based authentication mechanism.
       * The identifier  ``com.vmware.vapi.std.security.bearer_token``  for SAML bearer token based authentication mechanism.
       * The identifier  ``com.vmware.vapi.std.security.session_id``  for session based authentication mechanism.
       * The identifier  ``com.vmware.vapi.std.security.user_pass``  for username and password based authentication mechanism.

Returns:

- (`String`)

    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb', line 594

    class AuthenticationInfo < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.vapi.metadata.authentication.authentication_info',
                    {
                        'scheme_type' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType'),
                        'session_manager' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'scheme' => VAPI::Bindings::StringType.instance,
                    },
                    AuthenticationInfo,
                    false,
                    nil)
            end
        end

        attr_accessor :scheme_type,
                      :session_manager,
                      :scheme

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType``   enumerated type  provides  enumeration values  for the set of valid authentication scheme types.
        # @!attribute [rw] sessionless
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
        # @!attribute [rw] session_aware
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
        class SchemeType < VAPI::Bindings::VapiEnum

            class << self
                # Holds (gets or creates) the binding type metadata for this enumeration type.
                # @scope class
                # @return [VAPI::Bindings::EnumType] the binding type
                def binding_type
                    @binding_type ||= VAPI::Bindings::EnumType.new(
                        'com.vmware.vapi.metadata.authentication.authentication_info.scheme_type',
                        SchemeType)
                end

                # Converts from a string value (perhaps off the wire) to an instance
                # of this enum type.
                # @param value [String] the actual value of the enum instance
                # @return [SchemeType] the instance found for the value, otherwise
                #         an unknown instance will be built for the value
                def from_string(value)
                    begin
                        const_get(value)
                    rescue NameError
                        SchemeType.new('UNKNOWN', value)
                    end
                end
            end

            private

            # Constructs a new instance.
            # @param value [String] the actual value of the enum instance
            # @param unknown [String] the unknown value when value is 'UKNOWN'
            def initialize(value, unknown=nil)
                super(self.class.binding_type, value, unknown)
            end

            public

            # @!attribute [rw] sessionless
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
            SESSIONLESS = SchemeType.new('SESSIONLESS')

            # @!attribute [rw] session_aware
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
            SESSION_AWARE = SchemeType.new('SESSION_AWARE')

        end

    end

### - (`Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType`) scheme_type

The type of the authentication scheme.

Returns:

- (`Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType`)

    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb', line 594

    class AuthenticationInfo < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.vapi.metadata.authentication.authentication_info',
                    {
                        'scheme_type' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType'),
                        'session_manager' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'scheme' => VAPI::Bindings::StringType.instance,
                    },
                    AuthenticationInfo,
                    false,
                    nil)
            end
        end

        attr_accessor :scheme_type,
                      :session_manager,
                      :scheme

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType``   enumerated type  provides  enumeration values  for the set of valid authentication scheme types.
        # @!attribute [rw] sessionless
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
        # @!attribute [rw] session_aware
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
        class SchemeType < VAPI::Bindings::VapiEnum

            class << self
                # Holds (gets or creates) the binding type metadata for this enumeration type.
                # @scope class
                # @return [VAPI::Bindings::EnumType] the binding type
                def binding_type
                    @binding_type ||= VAPI::Bindings::EnumType.new(
                        'com.vmware.vapi.metadata.authentication.authentication_info.scheme_type',
                        SchemeType)
                end

                # Converts from a string value (perhaps off the wire) to an instance
                # of this enum type.
                # @param value [String] the actual value of the enum instance
                # @return [SchemeType] the instance found for the value, otherwise
                #         an unknown instance will be built for the value
                def from_string(value)
                    begin
                        const_get(value)
                    rescue NameError
                        SchemeType.new('UNKNOWN', value)
                    end
                end
            end

            private

            # Constructs a new instance.
            # @param value [String] the actual value of the enum instance
            # @param unknown [String] the unknown value when value is 'UKNOWN'
            def initialize(value, unknown=nil)
                super(self.class.binding_type, value, unknown)
            end

            public

            # @!attribute [rw] sessionless
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
            SESSIONLESS = SchemeType.new('SESSIONLESS')

            # @!attribute [rw] session_aware
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
            SESSION_AWARE = SchemeType.new('SESSION_AWARE')

        end

    end

### - (`String`) session_manager

In a session aware authentication scheme, a session manager is required that supports ``create`` , ``delete`` and ``keepAlive`` methods . The fully qualified class name of the session manager is provided in :attr:`Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo.session_manager` field . This class is responsible for handling sessions. This field is optional and it is only relevant when the value of ``schemeType`` is :attr:`Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType.SESSION_AWARE` .

Returns:

- (`String`)

    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb', line 594

    class AuthenticationInfo < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.vapi.metadata.authentication.authentication_info',
                    {
                        'scheme_type' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType'),
                        'session_manager' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'scheme' => VAPI::Bindings::StringType.instance,
                    },
                    AuthenticationInfo,
                    false,
                    nil)
            end
        end

        attr_accessor :scheme_type,
                      :session_manager,
                      :scheme

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType``   enumerated type  provides  enumeration values  for the set of valid authentication scheme types.
        # @!attribute [rw] sessionless
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
        # @!attribute [rw] session_aware
        #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
        #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
        class SchemeType < VAPI::Bindings::VapiEnum

            class << self
                # Holds (gets or creates) the binding type metadata for this enumeration type.
                # @scope class
                # @return [VAPI::Bindings::EnumType] the binding type
                def binding_type
                    @binding_type ||= VAPI::Bindings::EnumType.new(
                        'com.vmware.vapi.metadata.authentication.authentication_info.scheme_type',
                        SchemeType)
                end

                # Converts from a string value (perhaps off the wire) to an instance
                # of this enum type.
                # @param value [String] the actual value of the enum instance
                # @return [SchemeType] the instance found for the value, otherwise
                #         an unknown instance will be built for the value
                def from_string(value)
                    begin
                        const_get(value)
                    rescue NameError
                        SchemeType.new('UNKNOWN', value)
                    end
                end
            end

            private

            # Constructs a new instance.
            # @param value [String] the actual value of the enum instance
            # @param unknown [String] the unknown value when value is 'UKNOWN'
            def initialize(value, unknown=nil)
                super(self.class.binding_type, value, unknown)
            end

            public

            # @!attribute [rw] sessionless
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session less authentication scheme, the user is authenticated on every  method . There is no explicit session establishment.
            SESSIONLESS = SchemeType.new('SESSIONLESS')

            # @!attribute [rw] session_aware
            #     @return [Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType]
            #     Indicates that the scheme is a session aware authentication scheme. It requires an explicit login before executing a  method  and logout when a session terminates. A  class  might choose to have a session aware scheme if it wants to associate some state corresponding to the user until the user logs out or if it wants to mitigate the cost of authenticating the user on every  method .
            SESSION_AWARE = SchemeType.new('SESSION_AWARE')

        end

    end

## Class Method Details

### + (`VAPI::Bindings::StructType`) binding_type

Holds (gets or creates) the binding type metadata for this structure type.

Returns:

- (`VAPI::Bindings::StructType`) —

  the binding type

    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vapi/metadata/authentication.rb', line 600

    def binding_type
        @binding_type ||= VAPI::Bindings::StructType.new(
            'com.vmware.vapi.metadata.authentication.authentication_info',
            {
                'scheme_type' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Vapi::Metadata::Authentication::AuthenticationInfo::SchemeType'),
                'session_manager' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                'scheme' => VAPI::Bindings::StringType.instance,
            },
            AuthenticationInfo,
            false,
            nil)
    end