oci 2.0.2 → 2.0.3

data/lib/oci/core/models/instance_source_via_image_details.rb

@@ -0,0 +1,128 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+require_relative 'instance_source_details'
+
+module OCI
+  class Core::Models::InstanceSourceViaImageDetails < Core::Models::InstanceSourceDetails
+    # The OCID of the image used to boot the instance.
+    # @return [String]
+    attr_accessor :image_id
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      attributes['sourceType'] = 'image'
+
+      super(attributes)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'imageId']
+        self.image_id = attributes[:'imageId']
+      end
+
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other_object to be compared
+    def ==(other_object)
+      return true if self.equal?(other_object)
+      self.class == other_object.class &&
+          source_type == other_object.source_type &&
+          image_id == other_object.image_id
+    end
+
+    # @see the `==` method
+    # @param [Object] other_object to be compared
+    def eql?(other_object)
+      self == other_object
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [source_type, image_id].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value 
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      { 
+        :'source_type' => :'sourceType',
+        :'image_id' => :'imageId'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'source_type' => :'String',
+        :'image_id' => :'String'
+      }
+    end
+  end
+end

data/lib/oci/core/models/internet_gateway.rb

@@ -131,10 +131,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -152,7 +152,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/core/models/ip_sec_connection.rb

@@ -142,10 +142,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -163,7 +163,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/core/models/ip_sec_connection_device_config.rb

@@ -80,10 +80,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -101,7 +101,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/core/models/ip_sec_connection_device_status.rb

@@ -83,10 +83,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -104,7 +104,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/core/models/launch_instance_details.rb

@@ -38,14 +38,16 @@ module OCI
     # @return [Hash<String, Object>]
     attr_accessor :extended_metadata
 
-    # Deprecated. Instead use `hostnameLabel` in
+    # Deprecated. Instead Use `hostnameLabel` in
     # {CreateVnicDetails}.
     # If you provide both, the values must match.
     # 
     # @return [String]
     attr_accessor :hostname_label
 
-    # The OCID of the image used to boot the instance.
+    # Deprecated. Use `sourceDetails` with {#instance_source_via_image_details instance_source_via_image_details}
+    # source type instead. If you specify values for both, the values must match.
+    # 
     # @return [String]
     attr_accessor :image_id
 
@@ -147,6 +149,10 @@ module OCI
     # @return [String]
     attr_accessor :shape
 
+    # Details for creating an instance.
+    # @return [OCI::Core::Models::InstanceSourceDetails]
+    attr_accessor :source_details
+
     # Deprecated. Instead use `subnetId` in
     # {CreateVnicDetails}.
     # At least one of them is required; if you provide both, the values must match.
@@ -203,6 +209,10 @@ module OCI
         self.shape = attributes[:'shape']
       end
 
+      if attributes[:'sourceDetails']
+        self.source_details = attributes[:'sourceDetails']
+      end
+
       if attributes[:'subnetId']
         self.subnet_id = attributes[:'subnetId']
       end
@@ -224,6 +234,7 @@ module OCI
           ipxe_script == other_object.ipxe_script &&
           metadata == other_object.metadata &&
           shape == other_object.shape &&
+          source_details == other_object.source_details &&
           subnet_id == other_object.subnet_id
     end
 
@@ -236,7 +247,7 @@ module OCI
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [availability_domain, compartment_id, create_vnic_details, display_name, extended_metadata, hostname_label, image_id, ipxe_script, metadata, shape, subnet_id].hash
+      [availability_domain, compartment_id, create_vnic_details, display_name, extended_metadata, hostname_label, image_id, ipxe_script, metadata, shape, source_details, subnet_id].hash
     end
 
     # Builds the object from hash
@@ -249,10 +260,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -270,7 +281,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end
@@ -312,6 +323,7 @@ module OCI
         :'ipxe_script' => :'ipxeScript',
         :'metadata' => :'metadata',
         :'shape' => :'shape',
+        :'source_details' => :'sourceDetails',
         :'subnet_id' => :'subnetId'
       }
     end
@@ -329,6 +341,7 @@ module OCI
         :'ipxe_script' => :'String',
         :'metadata' => :'Hash<String, String>',
         :'shape' => :'String',
+        :'source_details' => :'OCI::Core::Models::InstanceSourceDetails',
         :'subnet_id' => :'String'
       }
     end

data/lib/oci/core/models/letter_of_authority.rb

@@ -117,10 +117,10 @@ module OCI
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -138,7 +138,7 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = send(attr)
+        value = public_send(attr)
         next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end

data/lib/oci/core/models/local_peering_gateway.rb

@@ -0,0 +1,271 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Core::Models::LocalPeeringGateway
+
+    LIFECYCLE_STATE_ENUM = [LIFECYCLE_STATE_PROVISIONING = 'PROVISIONING',
+                LIFECYCLE_STATE_AVAILABLE = 'AVAILABLE',
+                LIFECYCLE_STATE_TERMINATING = 'TERMINATING',
+                LIFECYCLE_STATE_TERMINATED = 'TERMINATED',
+                LIFECYCLE_STATE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    PEERING_STATUS_ENUM = [PEERING_STATUS_INVALID = 'INVALID',
+                PEERING_STATUS_NEW = 'NEW',
+                PEERING_STATUS_PEERED = 'PEERED',
+                PEERING_STATUS_PENDING = 'PENDING',
+                PEERING_STATUS_REVOKED = 'REVOKED',
+                PEERING_STATUS_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+    # The OCID of the compartment containing the LPG.
+    # @return [String]
+    attr_accessor :compartment_id
+
+    # A user-friendly name. Does not have to be unique, and it's changeable. Avoid
+    # entering confidential information.
+    # 
+    # @return [String]
+    attr_accessor :display_name
+
+    # The LPG's Oracle ID (OCID).
+    # @return [String]
+    attr_accessor :id
+
+    # Whether the VCN at the other end of the peering is in a different tenancy.
+    # 
+    # Example: `false`
+    # 
+    # @return [BOOLEAN]
+    attr_accessor :is_cross_tenancy_peering
+
+    # The LPG's current lifecycle state.
+    # @return [String]
+    attr_accessor :lifecycle_state
+
+    # The range of IP addresses available on the VCN at the other
+    # end of the peering from this LPG. The value is `null` if the LPG is not peered.
+    # You can use this as the destination CIDR for a route rule to route a subnet's
+    # traffic to this LPG.
+    # 
+    # Example: `192.168.0.0/16`
+    # 
+    # @return [String]
+    attr_accessor :peer_advertised_cidr
+
+    # Whether the LPG is peered with another LPG. `NEW` means the LPG has not yet been
+    # peered. `PENDING` means the peering is being established. `REVOKED` means the
+    # LPG at the other end of the peering has been deleted.
+    # 
+    # @return [String]
+    attr_accessor :peering_status
+
+    # Additional information regarding the peering status, if applicable.
+    # @return [String]
+    attr_accessor :peering_status_details
+
+    # The date and time the LPG was created, in the format defined by RFC3339.
+    # 
+    # Example: `2016-08-25T21:10:29.600Z`
+    # 
+    # @return [DateTime]
+    attr_accessor :time_created
+
+    # The OCID of the VCN the LPG belongs to.
+    # @return [String]
+    attr_accessor :vcn_id
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'compartmentId']
+        self.compartment_id = attributes[:'compartmentId']
+      end
+
+      if attributes[:'displayName']
+        self.display_name = attributes[:'displayName']
+      end
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+
+      if attributes[:'isCrossTenancyPeering']
+        self.is_cross_tenancy_peering = attributes[:'isCrossTenancyPeering']
+      end
+
+      if attributes[:'lifecycleState']
+        self.lifecycle_state = attributes[:'lifecycleState']
+      end
+
+      if attributes[:'peerAdvertisedCidr']
+        self.peer_advertised_cidr = attributes[:'peerAdvertisedCidr']
+      end
+
+      if attributes[:'peeringStatus']
+        self.peering_status = attributes[:'peeringStatus']
+      end
+
+      if attributes[:'peeringStatusDetails']
+        self.peering_status_details = attributes[:'peeringStatusDetails']
+      end
+
+      if attributes[:'timeCreated']
+        self.time_created = attributes[:'timeCreated']
+      end
+
+      if attributes[:'vcnId']
+        self.vcn_id = attributes[:'vcnId']
+      end
+
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] lifecycle_state Object to be assigned
+    def lifecycle_state=(lifecycle_state)
+      if lifecycle_state && !LIFECYCLE_STATE_ENUM.include?(lifecycle_state)
+        @lifecycle_state = LIFECYCLE_STATE_UNKNOWN_ENUM_VALUE
+      else
+        @lifecycle_state = lifecycle_state
+      end
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] peering_status Object to be assigned
+    def peering_status=(peering_status)
+      if peering_status && !PEERING_STATUS_ENUM.include?(peering_status)
+        @peering_status = PEERING_STATUS_UNKNOWN_ENUM_VALUE
+      else
+        @peering_status = peering_status
+      end
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other_object to be compared
+    def ==(other_object)
+      return true if self.equal?(other_object)
+      self.class == other_object.class &&
+          compartment_id == other_object.compartment_id &&
+          display_name == other_object.display_name &&
+          id == other_object.id &&
+          is_cross_tenancy_peering == other_object.is_cross_tenancy_peering &&
+          lifecycle_state == other_object.lifecycle_state &&
+          peer_advertised_cidr == other_object.peer_advertised_cidr &&
+          peering_status == other_object.peering_status &&
+          peering_status_details == other_object.peering_status_details &&
+          time_created == other_object.time_created &&
+          vcn_id == other_object.vcn_id
+    end
+
+    # @see the `==` method
+    # @param [Object] other_object to be compared
+    def eql?(other_object)
+      self == other_object
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [compartment_id, display_name, id, is_cross_tenancy_peering, lifecycle_state, peer_advertised_cidr, peering_status, peering_status_details, time_created, vcn_id].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.public_send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OCI::Internal::Util.convert_to_type($1, v) } )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.public_send("#{key}=", OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value 
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      { 
+        :'compartment_id' => :'compartmentId',
+        :'display_name' => :'displayName',
+        :'id' => :'id',
+        :'is_cross_tenancy_peering' => :'isCrossTenancyPeering',
+        :'lifecycle_state' => :'lifecycleState',
+        :'peer_advertised_cidr' => :'peerAdvertisedCidr',
+        :'peering_status' => :'peeringStatus',
+        :'peering_status_details' => :'peeringStatusDetails',
+        :'time_created' => :'timeCreated',
+        :'vcn_id' => :'vcnId'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'compartment_id' => :'String',
+        :'display_name' => :'String',
+        :'id' => :'String',
+        :'is_cross_tenancy_peering' => :'BOOLEAN',
+        :'lifecycle_state' => :'String',
+        :'peer_advertised_cidr' => :'String',
+        :'peering_status' => :'String',
+        :'peering_status_details' => :'String',
+        :'time_created' => :'DateTime',
+        :'vcn_id' => :'String'
+      }
+    end
+  end
+end