oci 2.0.2 → 2.0.3

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

@@ -62,10 +62,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
 
@@ -83,7 +83,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/image.rb

@@ -162,10 +162,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
 
@@ -183,7 +183,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/image_source_details.rb

@@ -67,10 +67,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
 
@@ -88,7 +88,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/image_source_via_object_storage_tuple_details.rb

@@ -77,10 +77,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
 
@@ -98,7 +98,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/image_source_via_object_storage_uri_details.rb

@@ -59,10 +59,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
 
@@ -80,7 +80,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/ingress_security_rule.rb

@@ -121,10 +121,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
 
@@ -142,7 +142,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/instance.rb

@@ -47,8 +47,7 @@ module OCI
     # @return [String]
     attr_accessor :id
 
-    # The image used to boot the instance. You can enumerate all available images by calling
-    # {#list_images list_images}.
+    # Deprecated. Use `sourceDetails` instead.
     # 
     # @return [String]
     attr_accessor :image_id
@@ -101,6 +100,10 @@ module OCI
     # @return [String]
     attr_accessor :shape
 
+    # Details for creating an instance
+    # @return [OCI::Core::Models::InstanceSourceDetails]
+    attr_accessor :source_details
+
     # The date and time the instance was created, in the format defined by RFC3339.
     # 
     # Example: `2016-08-25T21:10:29.600Z`
@@ -161,6 +164,10 @@ module OCI
         self.shape = attributes[:'shape']
       end
 
+      if attributes[:'sourceDetails']
+        self.source_details = attributes[:'sourceDetails']
+      end
+
       if attributes[:'timeCreated']
         self.time_created = attributes[:'timeCreated']
       end
@@ -193,6 +200,7 @@ module OCI
           metadata == other_object.metadata &&
           region == other_object.region &&
           shape == other_object.shape &&
+          source_details == other_object.source_details &&
           time_created == other_object.time_created
     end
 
@@ -205,7 +213,7 @@ module OCI
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [availability_domain, compartment_id, display_name, extended_metadata, id, image_id, ipxe_script, lifecycle_state, metadata, region, shape, time_created].hash
+      [availability_domain, compartment_id, display_name, extended_metadata, id, image_id, ipxe_script, lifecycle_state, metadata, region, shape, source_details, time_created].hash
     end
 
     # Builds the object from hash
@@ -218,10 +226,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
 
@@ -239,7 +247,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
@@ -282,6 +290,7 @@ module OCI
         :'metadata' => :'metadata',
         :'region' => :'region',
         :'shape' => :'shape',
+        :'source_details' => :'sourceDetails',
         :'time_created' => :'timeCreated'
       }
     end
@@ -300,6 +309,7 @@ module OCI
         :'metadata' => :'Hash<String, String>',
         :'region' => :'String',
         :'shape' => :'String',
+        :'source_details' => :'OCI::Core::Models::InstanceSourceDetails',
         :'time_created' => :'DateTime'
       }
     end

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

@@ -12,27 +12,27 @@ module OCI
                 LIFECYCLE_STATE_FAILED = 'FAILED',
                 LIFECYCLE_STATE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
 
-    # The OCID of the compartment to contain the serial console connection.
+    # The OCID of the compartment to contain the console connection.
     # @return [String]
     attr_accessor :compartment_id
 
-    # The SSH connection string for the serial console connection.
+    # The SSH connection string for the console connection.
     # @return [String]
     attr_accessor :connection_string
 
-    # The SSH public key fingerprint for the serial console connection.
+    # The SSH public key fingerprint for the console connection.
     # @return [String]
     attr_accessor :fingerprint
 
-    # The OCID of the serial console connection.
+    # The OCID of the console connection.
     # @return [String]
     attr_accessor :id
 
-    # The OCID of the instance the serial console connection connects to.
+    # The OCID of the instance the console connection connects to.
     # @return [String]
     attr_accessor :instance_id
 
-    # The current state of the serial console connection.
+    # The current state of the console connection.
     # @return [String]
     attr_accessor :lifecycle_state
 
@@ -116,10 +116,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
 
@@ -137,7 +137,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/instance_credentials.rb

@@ -62,10 +62,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
 
@@ -83,7 +83,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/instance_source_details.rb

@@ -0,0 +1,135 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Core::Models::InstanceSourceDetails
+    # The source type for the instance.
+    # Use `image` when specifying the image OCID. Use `bootVolume` when specifying
+    # the boot volume OCID.
+    # 
+    # @return [String]
+    attr_accessor :source_type
+
+
+    # Given the hash representation of a subtype of this class,
+    # use the info in the hash to return the class of the subtype.
+    def self.get_subtype(object_hash)
+      type = object_hash[:'sourceType']
+
+      return 'OCI::Core::Models::InstanceSourceViaImageDetails' if type == 'image'
+      return 'OCI::Core::Models::InstanceSourceViaBootVolumeDetails' if type == 'bootVolume'
+
+      # TODO: Log a warning when the subtype is not found.
+      return 'OCI::Core::Models::InstanceSourceDetails'
+    end
+
+    # 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[:'sourceType']
+        self.source_type = attributes[:'sourceType']
+      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
+    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].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'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'source_type' => :'String'
+      }
+    end
+  end
+end

data/lib/oci/core/models/instance_source_via_boot_volume_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::InstanceSourceViaBootVolumeDetails < Core::Models::InstanceSourceDetails
+    # The OCID of the boot volume used to boot the instance.
+    # @return [String]
+    attr_accessor :boot_volume_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'] = 'bootVolume'
+
+      super(attributes)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'bootVolumeId']
+        self.boot_volume_id = attributes[:'bootVolumeId']
+      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 &&
+          boot_volume_id == other_object.boot_volume_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, boot_volume_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',
+        :'boot_volume_id' => :'bootVolumeId'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'source_type' => :'String',
+        :'boot_volume_id' => :'String'
+      }
+    end
+  end
+end