oci 2.0.1 → 2.0.2

data/lib/oci/database/models/create_db_home_details.rb

@@ -91,8 +91,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/database/models/create_db_home_with_db_system_id_details.rb

@@ -100,8 +100,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/database/models/data_guard_association.rb

@@ -300,8 +300,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/database/models/data_guard_association_summary.rb

@@ -0,0 +1,374 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Database::Models::DataGuardAssociationSummary
+
+    LIFECYCLE_STATE_ENUM = [LIFECYCLE_STATE_PROVISIONING = 'PROVISIONING',
+                LIFECYCLE_STATE_AVAILABLE = 'AVAILABLE',
+                LIFECYCLE_STATE_UPDATING = 'UPDATING',
+                LIFECYCLE_STATE_TERMINATING = 'TERMINATING',
+                LIFECYCLE_STATE_TERMINATED = 'TERMINATED',
+                LIFECYCLE_STATE_FAILED = 'FAILED',
+                LIFECYCLE_STATE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    PEER_ROLE_ENUM = [PEER_ROLE_PRIMARY = 'PRIMARY',
+                PEER_ROLE_STANDBY = 'STANDBY',
+                PEER_ROLE_DISABLED_STANDBY = 'DISABLED_STANDBY',
+                PEER_ROLE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    PROTECTION_MODE_ENUM = [PROTECTION_MODE_MAXIMUM_AVAILABILITY = 'MAXIMUM_AVAILABILITY',
+                PROTECTION_MODE_MAXIMUM_PERFORMANCE = 'MAXIMUM_PERFORMANCE',
+                PROTECTION_MODE_MAXIMUM_PROTECTION = 'MAXIMUM_PROTECTION',
+                PROTECTION_MODE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    ROLE_ENUM = [ROLE_PRIMARY = 'PRIMARY',
+                ROLE_STANDBY = 'STANDBY',
+                ROLE_DISABLED_STANDBY = 'DISABLED_STANDBY',
+                ROLE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+
+    TRANSPORT_TYPE_ENUM = [TRANSPORT_TYPE_SYNC = 'SYNC',
+                TRANSPORT_TYPE_ASYNC = 'ASYNC',
+                TRANSPORT_TYPE_FASTSYNC = 'FASTSYNC',
+                TRANSPORT_TYPE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
+
+    # The lag time between updates to the primary database and application of the redo data on the standby database,
+    # as computed by the reporting database.
+    # 
+    # Example: `9 seconds`
+    # 
+    # @return [String]
+    attr_accessor :apply_lag
+
+    # The rate at which redo logs are synced between the associated databases.
+    # 
+    # Example: `180 Mb per second`
+    # 
+    # @return [String]
+    attr_accessor :apply_rate
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the reporting database.
+    # @return [String]
+    attr_accessor :database_id
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the Data Guard association.
+    # @return [String]
+    attr_accessor :id
+
+    # Additional information about the current lifecycleState, if available.
+    # 
+    # @return [String]
+    attr_accessor :lifecycle_details
+
+    # The current state of the Data Guard association.
+    # @return [String]
+    attr_accessor :lifecycle_state
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the peer database's Data Guard association.
+    # @return [String]
+    attr_accessor :peer_data_guard_association_id
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the associated peer database.
+    # @return [String]
+    attr_accessor :peer_database_id
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the database home containing the associated peer database.
+    # 
+    # @return [String]
+    attr_accessor :peer_db_home_id
+
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the DB System containing the associated
+    # peer database.
+    # 
+    # @return [String]
+    attr_accessor :peer_db_system_id
+
+    # The role of the peer database in this Data Guard association.
+    # @return [String]
+    attr_accessor :peer_role
+
+    # The protection mode of this Data Guard association. For more information, see
+    # [Oracle Data Guard Protection Modes](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-protection-modes.htm#SBYDB02000)
+    # in the Oracle Data Guard documentation.
+    # 
+    # @return [String]
+    attr_accessor :protection_mode
+
+    # The role of the reporting database in this Data Guard association.
+    # @return [String]
+    attr_accessor :role
+
+    # The date and time the Data Guard Association was created.
+    # @return [DateTime]
+    attr_accessor :time_created
+
+    # The redo transport type used by this Data Guard association.  For more information, see
+    # [Redo Transport Services](http://docs.oracle.com/database/122/SBYDB/oracle-data-guard-redo-transport-services.htm#SBYDB00400)
+    # in the Oracle Data Guard documentation.
+    # 
+    # @return [String]
+    attr_accessor :transport_type
+
+
+    # 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[:'applyLag']
+        self.apply_lag = attributes[:'applyLag']
+      end
+
+      if attributes[:'applyRate']
+        self.apply_rate = attributes[:'applyRate']
+      end
+
+      if attributes[:'databaseId']
+        self.database_id = attributes[:'databaseId']
+      end
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+
+      if attributes[:'lifecycleDetails']
+        self.lifecycle_details = attributes[:'lifecycleDetails']
+      end
+
+      if attributes[:'lifecycleState']
+        self.lifecycle_state = attributes[:'lifecycleState']
+      end
+
+      if attributes[:'peerDataGuardAssociationId']
+        self.peer_data_guard_association_id = attributes[:'peerDataGuardAssociationId']
+      end
+
+      if attributes[:'peerDatabaseId']
+        self.peer_database_id = attributes[:'peerDatabaseId']
+      end
+
+      if attributes[:'peerDbHomeId']
+        self.peer_db_home_id = attributes[:'peerDbHomeId']
+      end
+
+      if attributes[:'peerDbSystemId']
+        self.peer_db_system_id = attributes[:'peerDbSystemId']
+      end
+
+      if attributes[:'peerRole']
+        self.peer_role = attributes[:'peerRole']
+      end
+
+      if attributes[:'protectionMode']
+        self.protection_mode = attributes[:'protectionMode']
+      end
+
+      if attributes[:'role']
+        self.role = attributes[:'role']
+      end
+
+      if attributes[:'timeCreated']
+        self.time_created = attributes[:'timeCreated']
+      end
+
+      if attributes[:'transportType']
+        self.transport_type = attributes[:'transportType']
+      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] peer_role Object to be assigned
+    def peer_role=(peer_role)
+      if peer_role && !PEER_ROLE_ENUM.include?(peer_role)
+        @peer_role = PEER_ROLE_UNKNOWN_ENUM_VALUE
+      else
+        @peer_role = peer_role
+      end
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] protection_mode Object to be assigned
+    def protection_mode=(protection_mode)
+      if protection_mode && !PROTECTION_MODE_ENUM.include?(protection_mode)
+        @protection_mode = PROTECTION_MODE_UNKNOWN_ENUM_VALUE
+      else
+        @protection_mode = protection_mode
+      end
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] role Object to be assigned
+    def role=(role)
+      if role && !ROLE_ENUM.include?(role)
+        @role = ROLE_UNKNOWN_ENUM_VALUE
+      else
+        @role = role
+      end
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] transport_type Object to be assigned
+    def transport_type=(transport_type)
+      if transport_type && !TRANSPORT_TYPE_ENUM.include?(transport_type)
+        @transport_type = TRANSPORT_TYPE_UNKNOWN_ENUM_VALUE
+      else
+        @transport_type = transport_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 &&
+          apply_lag == other_object.apply_lag &&
+          apply_rate == other_object.apply_rate &&
+          database_id == other_object.database_id &&
+          id == other_object.id &&
+          lifecycle_details == other_object.lifecycle_details &&
+          lifecycle_state == other_object.lifecycle_state &&
+          peer_data_guard_association_id == other_object.peer_data_guard_association_id &&
+          peer_database_id == other_object.peer_database_id &&
+          peer_db_home_id == other_object.peer_db_home_id &&
+          peer_db_system_id == other_object.peer_db_system_id &&
+          peer_role == other_object.peer_role &&
+          protection_mode == other_object.protection_mode &&
+          role == other_object.role &&
+          time_created == other_object.time_created &&
+          transport_type == other_object.transport_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
+      [apply_lag, apply_rate, database_id, id, lifecycle_details, lifecycle_state, peer_data_guard_association_id, peer_database_id, peer_db_home_id, peer_db_system_id, peer_role, protection_mode, role, time_created, transport_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
+      { 
+        :'apply_lag' => :'applyLag',
+        :'apply_rate' => :'applyRate',
+        :'database_id' => :'databaseId',
+        :'id' => :'id',
+        :'lifecycle_details' => :'lifecycleDetails',
+        :'lifecycle_state' => :'lifecycleState',
+        :'peer_data_guard_association_id' => :'peerDataGuardAssociationId',
+        :'peer_database_id' => :'peerDatabaseId',
+        :'peer_db_home_id' => :'peerDbHomeId',
+        :'peer_db_system_id' => :'peerDbSystemId',
+        :'peer_role' => :'peerRole',
+        :'protection_mode' => :'protectionMode',
+        :'role' => :'role',
+        :'time_created' => :'timeCreated',
+        :'transport_type' => :'transportType'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'apply_lag' => :'String',
+        :'apply_rate' => :'String',
+        :'database_id' => :'String',
+        :'id' => :'String',
+        :'lifecycle_details' => :'String',
+        :'lifecycle_state' => :'String',
+        :'peer_data_guard_association_id' => :'String',
+        :'peer_database_id' => :'String',
+        :'peer_db_home_id' => :'String',
+        :'peer_db_system_id' => :'String',
+        :'peer_role' => :'String',
+        :'protection_mode' => :'String',
+        :'role' => :'String',
+        :'time_created' => :'DateTime',
+        :'transport_type' => :'String'
+      }
+    end
+  end
+end

data/lib/oci/database/models/database.rb

@@ -8,8 +8,10 @@ module OCI
     LIFECYCLE_STATE_ENUM = [LIFECYCLE_STATE_PROVISIONING = 'PROVISIONING',
                 LIFECYCLE_STATE_AVAILABLE = 'AVAILABLE',
                 LIFECYCLE_STATE_UPDATING = 'UPDATING',
+                LIFECYCLE_STATE_BACKUP_IN_PROGRESS = 'BACKUP_IN_PROGRESS',
                 LIFECYCLE_STATE_TERMINATING = 'TERMINATING',
                 LIFECYCLE_STATE_TERMINATED = 'TERMINATED',
+                LIFECYCLE_STATE_RESTORE_FAILED = 'RESTORE_FAILED',
                 LIFECYCLE_STATE_FAILED = 'FAILED',
                 LIFECYCLE_STATE_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE']
 
@@ -21,6 +23,9 @@ module OCI
     # @return [String]
     attr_accessor :compartment_id
 
+    # @return [OCI::Database::Models::DbBackupConfig]
+    attr_accessor :db_backup_config
+
     # The OCID of the database home.
     # @return [String]
     attr_accessor :db_home_id
@@ -79,6 +84,10 @@ module OCI
         self.compartment_id = attributes[:'compartmentId']
       end
 
+      if attributes[:'dbBackupConfig']
+        self.db_backup_config = attributes[:'dbBackupConfig']
+      end
+
       if attributes[:'dbHomeId']
         self.db_home_id = attributes[:'dbHomeId']
       end
@@ -138,6 +147,7 @@ module OCI
       self.class == other_object.class &&
           character_set == other_object.character_set &&
           compartment_id == other_object.compartment_id &&
+          db_backup_config == other_object.db_backup_config &&
           db_home_id == other_object.db_home_id &&
           db_name == other_object.db_name &&
           db_unique_name == other_object.db_unique_name &&
@@ -159,7 +169,7 @@ module OCI
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [character_set, compartment_id, db_home_id, db_name, db_unique_name, db_workload, id, lifecycle_details, lifecycle_state, ncharacter_set, pdb_name, time_created].hash
+      [character_set, compartment_id, db_backup_config, db_home_id, db_name, db_unique_name, db_workload, id, lifecycle_details, lifecycle_state, ncharacter_set, pdb_name, time_created].hash
     end
 
     # Builds the object from hash
@@ -193,8 +203,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
@@ -227,6 +237,7 @@ module OCI
       { 
         :'character_set' => :'characterSet',
         :'compartment_id' => :'compartmentId',
+        :'db_backup_config' => :'dbBackupConfig',
         :'db_home_id' => :'dbHomeId',
         :'db_name' => :'dbName',
         :'db_unique_name' => :'dbUniqueName',
@@ -245,6 +256,7 @@ module OCI
       { 
         :'character_set' => :'String',
         :'compartment_id' => :'String',
+        :'db_backup_config' => :'OCI::Database::Models::DbBackupConfig',
         :'db_home_id' => :'String',
         :'db_name' => :'String',
         :'db_unique_name' => :'String',