oci 2.0.0 → 2.0.1

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

@@ -0,0 +1,225 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Database::Models::CreateDataGuardAssociationDetails
+
+    PROTECTION_MODE_ENUM = [PROTECTION_MODE_MAXIMUM_AVAILABILITY = 'MAXIMUM_AVAILABILITY',
+                PROTECTION_MODE_MAXIMUM_PERFORMANCE = 'MAXIMUM_PERFORMANCE',
+                PROTECTION_MODE_MAXIMUM_PROTECTION = 'MAXIMUM_PROTECTION']
+
+
+    TRANSPORT_TYPE_ENUM = [TRANSPORT_TYPE_SYNC = 'SYNC',
+                TRANSPORT_TYPE_ASYNC = 'ASYNC',
+                TRANSPORT_TYPE_FASTSYNC = 'FASTSYNC']
+
+    # Specifies where to create the associated database.
+    # \"ExistingDbSystem\" is the only supported `creationType` value.
+    # 
+    # @return [String]
+    attr_accessor :creation_type
+
+    # A strong password for the `SYS`, `SYSTEM`, and `PDB Admin` users to apply during standby creation.
+    # 
+    # The password must contain no fewer than nine characters and include:
+    # 
+    # * At least two uppercase characters.
+    # 
+    # * At least two lowercase characters.
+    # 
+    # * At least two numeric characters.
+    # 
+    # * At least two special characters. Valid special characters include \"_\", \"#\", and \"-\" only.
+    # 
+    # **The password MUST be the same as the primary admin password.**
+    # 
+    # @return [String]
+    attr_accessor :database_admin_password
+
+    # The protection mode to set up between the primary and standby databases. 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.
+    # 
+    # **IMPORTANT** - The only protection mode currently supported by the Database Service is MAXIMUM_PERFORMANCE.
+    # 
+    # @return [String]
+    attr_accessor :protection_mode
+
+    # The redo transport type to use for this Data Guard association.  Valid values depend on the specified `protectionMode`:
+    # 
+    # * MAXIMUM_AVAILABILITY - SYNC or FASTSYNC
+    # * MAXIMUM_PERFORMANCE - ASYNC
+    # * MAXIMUM_PROTECTION - SYNC
+    # 
+    # 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.
+    # 
+    # **IMPORTANT** - The only transport type currently supported by the Database Service is ASYNC.
+    # 
+    # @return [String]
+    attr_accessor :transport_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[:'creationType']
+
+      return 'OCI::Database::Models::CreateDataGuardAssociationToExistingDbSystemDetails' if type == 'ExistingDbSystem'
+
+      # TODO: Log a warning when the subtype is not found.
+      return 'OCI::Database::Models::CreateDataGuardAssociationDetails'
+    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[:'creationType']
+        self.creation_type = attributes[:'creationType']
+      end
+
+      if attributes[:'databaseAdminPassword']
+        self.database_admin_password = attributes[:'databaseAdminPassword']
+      end
+
+      if attributes[:'protectionMode']
+        self.protection_mode = attributes[:'protectionMode']
+      end
+
+      if attributes[:'transportType']
+        self.transport_type = attributes[:'transportType']
+      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)
+        fail "Invalid value for 'protection_mode': this must be one of the values in PROTECTION_MODE_ENUM."
+      else
+        @protection_mode = protection_mode
+      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)
+        fail "Invalid value for 'transport_type': this must be one of the values in TRANSPORT_TYPE_ENUM."
+      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 &&
+          creation_type == other_object.creation_type &&
+          database_admin_password == other_object.database_admin_password &&
+          protection_mode == other_object.protection_mode &&
+          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
+      [creation_type, database_admin_password, protection_mode, 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 = self.send(attr)
+        next if value.nil?
+        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
+      { 
+        :'creation_type' => :'creationType',
+        :'database_admin_password' => :'databaseAdminPassword',
+        :'protection_mode' => :'protectionMode',
+        :'transport_type' => :'transportType'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'creation_type' => :'String',
+        :'database_admin_password' => :'String',
+        :'protection_mode' => :'String',
+        :'transport_type' => :'String'
+      }
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+require_relative 'create_data_guard_association_details'
+
+module OCI
+  class Database::Models::CreateDataGuardAssociationToExistingDbSystemDetails < Database::Models::CreateDataGuardAssociationDetails
+    # The [OCID](https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm) of the DB System to create the standby database on.
+    # 
+    # @return [String]
+    attr_accessor :peer_db_system_id
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      attributes['creationType'] = 'ExistingDbSystem'
+
+      super(attributes)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes[:'peerDbSystemId']
+        self.peer_db_system_id = attributes[:'peerDbSystemId']
+      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 &&
+          creation_type == other_object.creation_type &&
+          database_admin_password == other_object.database_admin_password &&
+          protection_mode == other_object.protection_mode &&
+          transport_type == other_object.transport_type &&
+          peer_db_system_id == other_object.peer_db_system_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
+      [creation_type, database_admin_password, protection_mode, transport_type, peer_db_system_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 = self.send(attr)
+        next if value.nil?
+        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
+      { 
+        :'creation_type' => :'creationType',
+        :'database_admin_password' => :'databaseAdminPassword',
+        :'protection_mode' => :'protectionMode',
+        :'transport_type' => :'transportType',
+        :'peer_db_system_id' => :'peerDbSystemId'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'creation_type' => :'String',
+        :'database_admin_password' => :'String',
+        :'protection_mode' => :'String',
+        :'transport_type' => :'String',
+        :'peer_db_system_id' => :'String'
+      }
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+module OCI
+  class Database::Models::CreateDatabaseDetails
+
+    DB_WORKLOAD_ENUM = [DB_WORKLOAD_OLTP = 'OLTP',
+                DB_WORKLOAD_DSS = 'DSS']
+
+    # A strong password for SYS, SYSTEM, and PDB Admin. The password must be at least nine characters and contain at least two uppercase, two lowercase, two numbers, and two special characters. The special characters must be _, \\#, or -.
+    # @return [String]
+    attr_accessor :admin_password
+
+    # The character set for the database.  The default is AL32UTF8. Allowed values are:
+    # 
+    # AL32UTF8, AR8ADOS710, AR8ADOS720, AR8APTEC715, AR8ARABICMACS, AR8ASMO8X, AR8ISO8859P6, AR8MSWIN1256, AR8MUSSAD768, AR8NAFITHA711, AR8NAFITHA721, AR8SAKHR706, AR8SAKHR707, AZ8ISO8859P9E, BG8MSWIN, BG8PC437S, BLT8CP921, BLT8ISO8859P13, BLT8MSWIN1257, BLT8PC775, BN8BSCII, CDN8PC863, CEL8ISO8859P14, CL8ISO8859P5, CL8ISOIR111, CL8KOI8R, CL8KOI8U, CL8MACCYRILLICS, CL8MSWIN1251, EE8ISO8859P2, EE8MACCES, EE8MACCROATIANS, EE8MSWIN1250, EE8PC852, EL8DEC, EL8ISO8859P7, EL8MACGREEKS, EL8MSWIN1253, EL8PC437S, EL8PC851, EL8PC869, ET8MSWIN923, HU8ABMOD, HU8CWI2, IN8ISCII, IS8PC861, IW8ISO8859P8, IW8MACHEBREWS, IW8MSWIN1255, IW8PC1507, JA16EUC, JA16EUCTILDE, JA16SJIS, JA16SJISTILDE, JA16VMS, KO16KSCCS, KO16MSWIN949, LA8ISO6937, LA8PASSPORT, LT8MSWIN921, LT8PC772, LT8PC774, LV8PC1117, LV8PC8LR, LV8RST104090, N8PC865, NE8ISO8859P10, NEE8ISO8859P4, RU8BESTA, RU8PC855, RU8PC866, SE8ISO8859P3, TH8MACTHAIS, TH8TISASCII, TR8DEC, TR8MACTURKISHS, TR8MSWIN1254, TR8PC857, US7ASCII, US8PC437, UTF8, VN8MSWIN1258, VN8VN3, WE8DEC, WE8DG, WE8ISO8859P15, WE8ISO8859P9, WE8MACROMAN8S, WE8MSWIN1252, WE8NCR4970, WE8NEXTSTEP, WE8PC850, WE8PC858, WE8PC860, WE8ROMAN8, ZHS16CGB231280, ZHS16GBK, ZHT16BIG5, ZHT16CCDC, ZHT16DBT, ZHT16HKSCS, ZHT16MSWIN950, ZHT32EUC, ZHT32SOPS, ZHT32TRIS
+    # 
+    # @return [String]
+    attr_accessor :character_set
+
+    # The database name. It must begin with an alphabetic character and can contain a maximum of eight alphanumeric characters. Special characters are not permitted.
+    # @return [String]
+    attr_accessor :db_name
+
+    # Database workload type.
+    # @return [String]
+    attr_accessor :db_workload
+
+    # National character set for the database.  The default is AL16UTF16. Allowed values are:
+    # AL16UTF16 or UTF8.
+    # 
+    # @return [String]
+    attr_accessor :ncharacter_set
+
+    # Pluggable database name. It must begin with an alphabetic character and can contain a maximum of eight alphanumeric characters. Special characters are not permitted. Pluggable database should not be same as database name.
+    # @return [String]
+    attr_accessor :pdb_name
+
+
+    # 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[:'adminPassword']
+        self.admin_password = attributes[:'adminPassword']
+      end
+
+      if attributes[:'characterSet']
+        self.character_set = attributes[:'characterSet']
+      end
+
+      if attributes[:'dbName']
+        self.db_name = attributes[:'dbName']
+      end
+
+      if attributes[:'dbWorkload']
+        self.db_workload = attributes[:'dbWorkload']
+      end
+
+      if attributes[:'ncharacterSet']
+        self.ncharacter_set = attributes[:'ncharacterSet']
+      end
+
+      if attributes[:'pdbName']
+        self.pdb_name = attributes[:'pdbName']
+      end
+
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] db_workload Object to be assigned
+    def db_workload=(db_workload)
+      if db_workload && !DB_WORKLOAD_ENUM.include?(db_workload)
+        fail "Invalid value for 'db_workload': this must be one of the values in DB_WORKLOAD_ENUM."
+      else
+        @db_workload = db_workload
+      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 &&
+          admin_password == other_object.admin_password &&
+          character_set == other_object.character_set &&
+          db_name == other_object.db_name &&
+          db_workload == other_object.db_workload &&
+          ncharacter_set == other_object.ncharacter_set &&
+          pdb_name == other_object.pdb_name
+    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
+      [admin_password, character_set, db_name, db_workload, ncharacter_set, pdb_name].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 = self.send(attr)
+        next if value.nil?
+        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
+      { 
+        :'admin_password' => :'adminPassword',
+        :'character_set' => :'characterSet',
+        :'db_name' => :'dbName',
+        :'db_workload' => :'dbWorkload',
+        :'ncharacter_set' => :'ncharacterSet',
+        :'pdb_name' => :'pdbName'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      { 
+        :'admin_password' => :'String',
+        :'character_set' => :'String',
+        :'db_name' => :'String',
+        :'db_workload' => :'String',
+        :'ncharacter_set' => :'String',
+        :'pdb_name' => :'String'
+      }
+    end
+  end
+end