oci 2.0.1 → 2.0.2

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

@@ -186,8 +186,8 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
+        value = send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end
       hash

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

@@ -30,10 +30,14 @@ module OCI
     # @return [String]
     attr_accessor :display_name
 
-    # The volume's Oracle ID (OCID).
+    # The OCID of the volume.
     # @return [String]
     attr_accessor :id
 
+    # Specifies whether the cloned volume's data has finished copying from the source volume or backup.
+    # @return [BOOLEAN]
+    attr_accessor :is_hydrated
+
     # The current state of a volume.
     # @return [String]
     attr_accessor :lifecycle_state
@@ -42,10 +46,16 @@ module OCI
     # @return [Integer]
     attr_accessor :size_in_gbs
 
-    # The size of the volume in MBs. This field is deprecated. Please use sizeInGBs.
+    # The size of the volume in MBs. This field is deprecated. Use sizeInGBs instead.
     # @return [Integer]
     attr_accessor :size_in_mbs
 
+    # The volume source, either an existing volume in the same Availability Domain or a volume backup.
+    # If null, an empty volume is created.
+    # 
+    # @return [OCI::Core::Models::VolumeSourceDetails]
+    attr_accessor :source_details
+
     # The date and time the volume was created. Format defined by RFC3339.
     # @return [DateTime]
     attr_accessor :time_created
@@ -75,6 +85,10 @@ module OCI
         self.id = attributes[:'id']
       end
 
+      if attributes[:'isHydrated']
+        self.is_hydrated = attributes[:'isHydrated']
+      end
+
       if attributes[:'lifecycleState']
         self.lifecycle_state = attributes[:'lifecycleState']
       end
@@ -87,6 +101,10 @@ module OCI
         self.size_in_mbs = attributes[:'sizeInMBs']
       end
 
+      if attributes[:'sourceDetails']
+        self.source_details = attributes[:'sourceDetails']
+      end
+
       if attributes[:'timeCreated']
         self.time_created = attributes[:'timeCreated']
       end
@@ -112,9 +130,11 @@ module OCI
           compartment_id == other_object.compartment_id &&
           display_name == other_object.display_name &&
           id == other_object.id &&
+          is_hydrated == other_object.is_hydrated &&
           lifecycle_state == other_object.lifecycle_state &&
           size_in_gbs == other_object.size_in_gbs &&
           size_in_mbs == other_object.size_in_mbs &&
+          source_details == other_object.source_details &&
           time_created == other_object.time_created
     end
 
@@ -127,7 +147,7 @@ module OCI
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [availability_domain, compartment_id, display_name, id, lifecycle_state, size_in_gbs, size_in_mbs, time_created].hash
+      [availability_domain, compartment_id, display_name, id, is_hydrated, lifecycle_state, size_in_gbs, size_in_mbs, source_details, time_created].hash
     end
 
     # Builds the object from hash
@@ -161,8 +181,8 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
+        value = send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end
       hash
@@ -197,9 +217,11 @@ module OCI
         :'compartment_id' => :'compartmentId',
         :'display_name' => :'displayName',
         :'id' => :'id',
+        :'is_hydrated' => :'isHydrated',
         :'lifecycle_state' => :'lifecycleState',
         :'size_in_gbs' => :'sizeInGBs',
         :'size_in_mbs' => :'sizeInMBs',
+        :'source_details' => :'sourceDetails',
         :'time_created' => :'timeCreated'
       }
     end
@@ -211,9 +233,11 @@ module OCI
         :'compartment_id' => :'String',
         :'display_name' => :'String',
         :'id' => :'String',
+        :'is_hydrated' => :'BOOLEAN',
         :'lifecycle_state' => :'String',
         :'size_in_gbs' => :'Integer',
         :'size_in_mbs' => :'Integer',
+        :'source_details' => :'OCI::Core::Models::VolumeSourceDetails',
         :'time_created' => :'DateTime'
       }
     end

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

@@ -184,8 +184,8 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
+        value = send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end
       hash

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

@@ -196,8 +196,8 @@ module OCI
     def to_hash
       hash = {}
       self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        next if value.nil?
+        value = send(attr)
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
         hash[param] = _to_hash(value)
       end
       hash

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

@@ -0,0 +1,131 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Core::Models::VolumeSourceDetails
+    # @return [String]
+    attr_accessor :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[:'type']
+
+      return 'OCI::Core::Models::VolumeSourceFromVolumeDetails' if type == 'volume'
+      return 'OCI::Core::Models::VolumeSourceFromVolumeBackupDetails' if type == 'volumeBackup'
+
+      # TODO: Log a warning when the subtype is not found.
+      return 'OCI::Core::Models::VolumeSourceDetails'
+    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[:'type']
+        self.type = attributes[:'type']
+      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 &&
+          type == other_object.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
+      [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.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]]))
+        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 = 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
+      { 
+        :'type' => :'type'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'type' => :'String'
+      }
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+require_relative 'volume_source_details'
+
+module OCI
+  class Core::Models::VolumeSourceFromVolumeBackupDetails < Core::Models::VolumeSourceDetails
+    # The OCID of the volume backup.
+    # @return [String]
+    attr_accessor :id
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      attributes['type'] = 'volumeBackup'
+
+      super(attributes)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      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 &&
+          type == other_object.type &&
+          id == other_object.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
+      [type, 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.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]]))
+        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 = 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
+      { 
+        :'type' => :'type',
+        :'id' => :'id'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'type' => :'String',
+        :'id' => :'String'
+      }
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+require_relative 'volume_source_details'
+
+module OCI
+  class Core::Models::VolumeSourceFromVolumeDetails < Core::Models::VolumeSourceDetails
+    # The OCID of the volume.
+    # @return [String]
+    attr_accessor :id
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      attributes['type'] = 'volume'
+
+      super(attributes)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      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 &&
+          type == other_object.type &&
+          id == other_object.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
+      [type, 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.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]]))
+        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 = 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
+      { 
+        :'type' => :'type',
+        :'id' => :'id'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'type' => :'String',
+        :'id' => :'String'
+      }
+    end
+  end
+end