fog-oraclecloud 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfdb853230afc1e89dba20e81a39ef494234917f
-  data.tar.gz: 757d5807cbb9f31ec133be9821a51d6b0b6c8cff
+  metadata.gz: a4517e556687acd69faa9807cc250d1830eb0624
+  data.tar.gz: 86091d93411468a2face694fffbf86f883919910
 SHA512:
-  metadata.gz: 060f7511d4454b87de04176b24488db21088b81a1568faeee3920499af9a928f6f0138f75d36e369e1f401c9641a0c57a0f252f0931faf4fee18cc4da0535e6f
-  data.tar.gz: 83395c4a62880b05ff56f18c854538a8c2df526489e2965fb060ff2a65ea0055f4221dbba70c6677a98811c67ba0d01603113bdcf0e09417396c6ed1d9c71070
+  metadata.gz: e9741aad0ade9bb060e7011f675c51bb9d12a1c56067abc405600b4d1057bc4d32c87e85a0fad0bee43300cfe3700a78fbacc03dcb4089156b814b098e6d0e03
+  data.tar.gz: 8f3c6713655cb0f9f4594a752c396350bb9807b99ddd2174b1252d2673b7fed020e087dfa2ba2672a327185e4248ec92d9a9635f3e7a77257eb5b86bd9493108

data/lib/fog/oraclecloud/database.rb

@@ -6,12 +6,33 @@ module Fog
       model_path	'fog/oraclecloud/models/database'
       model				:instance
       collection	:instances
+      model       :backup
+      collection  :backups
+      model       :recovery
+      collection  :recoveries
+      model       :snapshot
+      collection  :snapshots
+      model       :server
+      collection  :servers
+      model       :patch
+      collection  :patches
 
 			request_path 'fog/oraclecloud/requests/database'
       request :list_instances
       request :get_instance
       request :create_instance
       request :delete_instance
+      request :list_backups
+      request :list_recoveries
+      request :list_snapshots
+      request :get_snapshot
+      request :create_snapshot
+      request :delete_snapshot
+      request :list_servers
+      request :scale_instance
+      request :backup_instance
+      request :recover_instance
+      request :list_patches
 
       class Real
 
@@ -66,9 +87,14 @@ module Fog
 
         def self.data 
           @data ||= {
-            :instances => {},
+            :instances  => {},
+            :snapshots  => {},
+            :servers    => {},
+            :backups    => {},
+            :recoveries => {},
             :deleted_at => {},
-            :created_at => {}
+            :created_at => {},
+            :maintenance_at => {}
           }
         end
 

data/lib/fog/oraclecloud/models/database/backup.rb

@@ -0,0 +1,37 @@
+require 'fog/core/model'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Backup < Fog::Model
+        identity  :db_tag, :aliases=>'dbTag'
+
+        attribute :backup_complete_date,  :aliases=>'backupCompleteDate'
+        attribute :status
+        attribute :database_id
+       
+        def completed?
+          status == "COMPLETED"
+        end
+
+        private
+
+        # Had to override reload as we need to pass the database_id
+        def reload
+          requires :identity, :database_id
+
+          data = begin
+            collection.get(database_id, identity)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+          return unless data
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/backups.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Backups < Fog::Collection
+
+        model Fog::OracleCloud::Database::Backup
+
+        def all(db_name)
+          data = service.list_backups(db_name).body['backupList']
+          load(data)
+        end
+
+        # There is no get service for backups in the Oracle Cloud
+        # Call the list and extract the backup given a tag
+        def get(db_name, tag)
+          data = {}
+          service.list_backups(db_name).body['backupList'].each { |b| 
+            if b['dbTag'] == tag then
+              data = b
+            end
+          }
+          new(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/instance.rb

@@ -39,8 +39,6 @@ module Fog
         attribute :compute_site_name
 
         # The following are only used to create an instance and are not returned in the list action
-        attribute :level
-        attribute :subscriptionType
         attribute :vmPublicKey
         attribute :parameters
 
@@ -75,6 +73,69 @@ module Fog
           service.delete_instance(service_name).body
         end
 
+        def scale(shape)
+          requires :service_name
+          service.scale_instance(service_name, :shape=>shape).body
+        end
+
+        def add_storage(size)
+          requires :service_name
+          service.scale_instance(service_name, :additional_storage=>size).body
+        end
+
+        def expand_storage(size, type=nil)
+          requires :service_name
+          if type.nil? then type = 'data' end
+          if type == 'backup' then type ='fra' end
+          service.scale_instance(service_name, :additional_storage=>size, :usage=>type).body
+        end
+
+        def snapshots
+          requires :service_name
+          service.snapshots.all(service_name)
+        end
+
+        def get_snapshot(snapshot_name)
+          requires :service_name
+          service.snapshots.get(service_name, snapshot_name)
+        end
+
+        def servers
+          requires :service_name
+          service.servers.all(service_name)
+        end
+
+        def backup
+          requires :service_name
+          service.backup_instance(service_name)
+        end
+
+        def backups
+          requires :service_name
+          service.backups.all(service_name)
+        end
+
+        def recover(type, value)
+          # Valid types are 'scn', 'tag' or 'timestamp'
+          requires :service_name
+          service.recover_instance(service_name, type, value)
+        end
+
+        def recover_latest
+          requires :service_name
+          service.recover_instance(service_name)
+        end
+
+        def recoveries
+          requires :service_name
+          service.recoveries.all(service_name)
+        end
+
+        def patches
+          requires :service_name
+          service.patches.all(service_name)
+        end
+
         private
 
         def create

data/lib/fog/oraclecloud/models/database/patch.rb

@@ -0,0 +1,34 @@
+require 'fog/core/model'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Patch < Fog::Model
+        identity  :id, :aliases=>'patchId'
+
+        attribute :number,                  :aliases=>'patchNumber'
+        attribute :category,                :aliases=>'patchCategory'
+        attribute :severity,                :aliases=>'patchSeverity'
+        attribute :includes_config_upgrade, :aliases=>'includesConfigUpgrade'
+        attribute :description,             :aliases=>'patchDescription'
+        attribute :release_url,             :aliases=>'patchReleaseUrl'
+        attribute :service_type,            :aliases=>'serviceType'
+        attribute :service_version,         :aliases=>'serviceVersion'
+        attribute :release_date,            :aliases=>'releaseDate'
+        attribute :entry_date,              :aliases=>'entryDate'
+        attribute :entry_user_id,           :aliases=>'entryUserId'
+        attribute :patch_type,              :aliases=>'patchType'
+        attribute :requires_restart,        :aliases=>'requiresRestart'
+        attribute :is_deleted,              :aliases=>'isDeleted'
+        attribute :is_customer_visible,     :aliases=>'isCustomerVisible'
+        attribute :is_auto_apply,           :aliases=>'isAutoApply'
+        attribute :induce_down_time,        :aliases=>'induceDownTime'
+        attribute :display_name,            :aliases=>'displayName'
+        attribute :release_version,         :aliases=>'releaseVersion'
+        attribute :service_editions,        :aliases=>'serviceEditions'
+      
+       
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/patches.rb

@@ -0,0 +1,18 @@
+require 'fog/core/collection'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Patches < Fog::Collection
+
+        model Fog::OracleCloud::Database::Patch
+
+        def all(db_name)
+          data = service.list_patches(db_name).body['availablePatches']
+          load(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/recoveries.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Recoveries < Fog::Collection
+
+        model Fog::OracleCloud::Database::Recovery
+
+        def all(db_name)
+          data = service.list_recoveries(db_name).body['recoveryList']
+          load(data)
+        end
+
+        # There is no get service for recoveries in the Oracle Cloud
+        # Call the list and extract the recovery 
+        def get(db_name, type=nil, value=nil)
+          clean_type = 'dbTag' if type == 'tag'
+          clean_type, value = ['latest', true] if type.nil?
+          data = service.list_recoveries(db_name).body['recoveryList'].find { |r| r[clean_type] == value }
+          new(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/recovery.rb

@@ -0,0 +1,43 @@
+require 'fog/core/model'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Recovery < Fog::Model
+
+        attribute :db_tag, :aliases=>'dbTag'
+        attribute :recovery_start_date,  :aliases=>'recoveryStartDate'
+        attribute :recovery_complete_date,  :aliases=>'recoveryCompleteDate'
+        attribute :status
+        attribute :latest
+        attribute :timestamp
+        attribute :database_id
+       
+        def completed?
+          status == "COMPLETED"
+        end
+
+        private
+
+        def reload
+          requires :database_id
+
+          data = begin
+            if !db_tag.nil? then
+              collection.get(database_id, 'tag', db_tag)
+            else
+              collection.get(database_id)
+            end
+          rescue Excon::Errors::SocketError
+            nil
+          end
+          return unless data
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/server.rb

@@ -0,0 +1,28 @@
+require 'fog/core/model'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Server < Fog::Model
+        identity :hostname
+
+        attribute :connect_descriptor
+        attribute :connect_descriptor_with_public_ip
+        attribute :created_by
+        attribute :creation_job_id
+        attribute :creation_time
+        attribute :initial_primary,     :aliases=>'initialPrimary'
+        attribute :listener_port,       :aliases=>'listenerPort'
+        attribute :pdb_name,            :aliases=>'pdbName'
+        attribute :reserved_ip,         :aliases=>'reservedIP'
+        attribute :shape
+        attribute :sid
+        attribute :status
+        attribute :storage_allocated,   :aliases=>'storageAllocated'
+
+        private
+
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/servers.rb

@@ -0,0 +1,18 @@
+require 'fog/core/collection'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Servers < Fog::Collection
+
+        model Fog::OracleCloud::Database::Server
+
+        def all(db_name)
+          data = service.list_servers(db_name).body
+          load(data)
+        end
+        
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/snapshot.rb

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Snapshot < Fog::Model
+        identity  :name
+
+        attribute :cloned_services_size,  :aliases=>'clonedServicesSize'
+        attribute :creation_time,  :aliases=>'creationTime'
+        attribute :cloned_services,  :aliases=>'clonedServices'
+        attribute :status
+        attribute :description
+
+        attribute :database_id
+       
+        def completed?
+          status == "Succeeded"
+        end
+
+        def deleting?
+          status == "Terminating"
+        end
+ 
+        def save
+          create
+        end
+
+        def destroy
+          requires :name, :database_id
+          service.delete_snapshot(database_id, name).body
+        end
+
+        # Had to override snapshot as we need to pass the database_id
+        def reload
+          requires :identity, :database_id
+
+          data = begin
+            collection.get(database_id, identity)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          return unless data
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        private
+
+        def create
+          requires :name, :description, :database_id 
+          data = service.create_snapshot(name, description, database_id)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/models/database/snapshots.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+
+module Fog
+  module OracleCloud
+    class Database
+      class Snapshots < Fog::Collection
+
+        model Fog::OracleCloud::Database::Snapshot
+
+        def all(db_name)
+          data = service.list_snapshots(db_name).body
+          load(data)
+        end
+        
+        def get(db_name, snapshot_name)
+          new(service.get_snapshot(db_name, snapshot_name).body)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/backup_instance.rb

@@ -0,0 +1,42 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+      	def backup_instance(service_name)
+          # Oracle Cloud requires an empty JSON object in the body
+          body_data     = {}
+        
+          response = request(
+            :method   => 'POST',
+            :expects  => 202,
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{service_name}/backups",
+            :body     => Fog::JSON.encode(body_data),
+          )
+          response.database_id = service_name
+          response
+        end
+      end
+
+      class Mock
+        def backup_instance(service_name)
+      		response = Excon::Response.new
+
+          if !self.data[:backups][service_name].is_a? Array then 
+            self.data[:backups][service_name] = []
+            self.data[:created_at][service_name] = []
+          end
+          self.data[:backups][service_name].push({
+            'backupCompleteDate'=>Time.now.strftime('%d-%b-%Y %H:%M:%S UTC'),
+            'dbTag'=>'TAG' + Time.now.strftime('%Y%m%dT%H%M%S'),
+            'status'=>'IN PROGRESS',
+            'database_id'=>service_name
+          })
+          self.data[:created_at][service_name].push(Time.now)
+          response.status = 202
+          response
+      	end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/create_instance.rb

@@ -47,6 +47,26 @@ module Fog
 
           self.data[:instances][service_name] = data
           self.data[:created_at][service_name] = Time.now
+
+          # Also create some compute nodes 
+          node = {
+            "status"=>"Running",
+            "creation_job_id"=>"5495118",
+            "creation_time"=>"Tue Jun 28 23:52:45 UTC 2016",
+            "created_by"=>"dbaasadmin",
+            "shape"=>"oc4",
+            "sid"=>"ORCL1",
+            "pdbName"=>"PDB1",
+            "listenerPort"=> 1521,
+            "connect_descriptor"=>"(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=db12c-xp-rac2)(PORT=1521))(ADDRESS=(PROTOCOL=TCP)(HOST=db12c-xp-rac1)(PORT=1521))(LOAD_BALANCE=ON)(FAILOVER=ON))(CONNECT_DATA=(SERVICE_NAME=PDB1.usexample.oraclecloud.internal)))",
+            "connect_descriptor_with_public_ip"=>"(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=129.144.23.176)(PORT=1521))(ADDRESS=(PROTOCOL=TCP)(HOST=129.144.23.112)(PORT=1521))(LOAD_BALANCE=ON)(FAILOVER=ON))(CONNECT_DATA=(SERVICE_NAME=PDB1.usexample.oraclecloud.internal)))",
+            "initialPrimary"=> true,
+            "storageAllocated"=> 97280,
+            "reservedIP"=>"129.144.23.112",
+            "hostname"=>"db12c-xp-rac1"
+          }
+          self.data[:servers][service_name] = [node]
+          
           response.status = 202
           response
       	end

data/lib/fog/oraclecloud/requests/database/create_snapshot.rb

@@ -0,0 +1,50 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+      	def create_snapshot(name, description, database_id)
+          body_data     = {
+            'name'              => name,
+            'description'       => description
+          }
+          body_data = body_data.reject {|key, value| value.nil?}
+        
+          response = request(
+            :method   => 'POST',
+            :expects  => 202,
+            :path     => "/paas/api/v1.1/instancemgmt/#{@identity_domain}/services/dbaas/instances/#{database_id}/snapshots",
+            :body     => Fog::JSON.encode(body_data),
+          )
+          # Store the database reference in the model, so that we can use it later
+          response.database_id = service_name
+          response
+        end
+      end
+
+      class Mock
+        def create_snapshot(name, description, database_id)
+      		response = Excon::Response.new
+
+          data = {
+            'name' => name,
+            'description' => description,
+            'creationTime' => Time.now,
+            'clonedServicesSize' => 1,
+            'status'=>'In Progress',
+            'database_id'=>database_id,
+            'clonedServices'=>[{
+              'clonedServiceName'=>'ClonedService1',
+              'clonedServiceCreationTime'=> Time.now
+              }]
+          }
+          if !self.data[:snapshots].key?(database_id) then self.data[:snapshots][database_id] = {} end
+          self.data[:snapshots][database_id][name] = data
+          self.data[:created_at][name] = Time.now
+          response.status = 202
+          response
+      	end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/delete_snapshot.rb

@@ -0,0 +1,26 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+        def delete_snapshot(db_name, snapshot_name)
+          request(
+            :method   => 'DELETE',
+            :expects  => 202,
+            :path     => "/paas/api/v1.1/instancemgmt/#{@identity_domain}/services/dbaas/instances/#{db_name}/snapshots/#{snapshot_name}"
+          )
+        end
+      end
+
+     class Mock
+        def delete_snapshot(db_name, snapshot_name)
+          response = Excon::Response.new
+          self.data[:snapshots][db_name][snapshot_name]['status'] = 'Terminating'
+          self.data[:deleted_at][snapshot_name] = Time.now
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/get_instance.rb

@@ -30,6 +30,13 @@ module Fog
                 instance = self.data[:instances][name]
                 self.data[:created_at].delete(name)
               end
+            when 'Maintenance'
+              info = self.data[:maintenance_at][name]
+              if Time.now - info['time'] >= Fog::Mock.delay
+                self.data[:instances][name]['status'] = 'Running'
+                self.data[:instances][name][info['attribute']] = info['value']
+                self.data[:maintenance_at].delete(name)
+              end
             end
             response.status = 200
             response.body = instance

data/lib/fog/oraclecloud/requests/database/get_snapshot.rb

@@ -0,0 +1,44 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+      	def get_snapshot(db_name, snapshot_name)
+ 					response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/api/v1.1/instancemgmt/#{@identity_domain}/services/dbaas/instances/#{db_name}/snapshots/#{snapshot_name}"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def get_snapshot(db_name, snapshot_name)
+          response = Excon::Response.new
+
+          if snapshot = self.data[:snapshots][db_name][snapshot_name]
+            case snapshot['status']
+            when 'Terminating'
+              if Time.now - self.data[:deleted_at][snapshot_name] >= Fog::Mock.delay
+                self.data[:deleted_at].delete(snapshot_name)
+                self.data[:snapshots][db_name].delete(snapshot_name)
+              end
+            when 'In Progress'
+              if Time.now - self.data[:created_at][snapshot_name] >= Fog::Mock.delay
+                self.data[:snapshots][db_name][snapshot_name]['status'] = 'Succeeded'
+                snapshot = self.data[:snapshots][db_name][snapshot_name]
+                self.data[:created_at].delete(snapshot_name)
+              end
+            end
+            response.status = 200
+            response.body = snapshot
+            response
+          else
+            raise Fog::OracleCloud::Database::NotFound.new("Snapshot #{snapshot_name} for #{db_name} does not exist");
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/list_backups.rb

@@ -0,0 +1,37 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+      	def list_backups(db_name)
+          response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{db_name}/backups"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def list_backups(db_name)
+          response = Excon::Response.new
+
+          backups = self.data[:backups][db_name]
+          backups.each_with_index { |b, i| 
+            if b['status'] = 'IN PROGRESS' then
+              if Time.now - self.data[:created_at][db_name][i] >= Fog::Mock.delay
+                self.data[:created_at][db_name].delete(i)
+                self.data[:backups][db_name][i]['status'] = 'COMPLETED'
+                b = self.data[:backups][db_name][i]
+              end
+            end
+          }
+          response.body = {
+            'backupList' => backups
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/list_patches.rb

@@ -0,0 +1,51 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+      	def list_patches(db_name)
+          response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{db_name}/patches"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def list_patches(db_name)
+          response = Excon::Response.new
+
+          # Fake a patch
+          response.body = {
+            'availablePatches' => [{
+              "patchId"=>"23054246-SE",
+              "patchNumber"=>"Patch_12.1.0.2.160719_SE",
+              "patchCategory"=>"DB",
+              "patchSeverity"=>"Normal",
+              "includesConfigUpgrade"=>false,
+              "patchDescription"=>"DB 12.1.0.2.160719 Jul 2016 PSU Standard Edition image",
+              "patchReleaseUrl"=>"https://support.oracle.com/epmos/faces/PatchDetail?patchId=23054246",
+              "serviceType"=>"DBaaS",
+              "serviceVersion"=>"12.1.0.2",
+              "releaseDate"=>"2016-07-16T01:40:00.000+0000",
+              "entryDate"=>"2016-10-07T20:57:33.121+0000",
+              "entryUserId"=>"OCLOUD9_SM_PLATFORM_APPID",
+              "patchType"=>"PSU",
+              "requiresRestart"=> true,
+              "serviceTypeVersions"=>"ANY",
+              "isDeleted"=> false,
+              "isCustomerVisible"=> false,
+              "isAutoApply"=> false,
+              "induceDownTime"=> false,
+              "displayName"=>"12.1.0.2.160719",
+              "releaseVersion"=>"12.1.0.2.160719",
+              "serviceEditions"=>"SE",
+            }]
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/list_recoveries.rb

@@ -0,0 +1,38 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+      	def list_recoveries(db_name)
+          response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{db_name}/backups/recovery/history"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def list_recoveries(db_name)
+          response = Excon::Response.new
+
+          recoveries = self.data[:recoveries][db_name]
+          recoveries.each_with_index { |r, i| 
+            if r['status'] = 'IN PROGRESS' then
+              if Time.now - self.data[:created_at][:recoveries][db_name][i] >= Fog::Mock.delay
+                self.data[:created_at][:recoveries][db_name].delete(i)
+                self.data[:recoveries][db_name][i]['status'] = 'COMPLETED'
+                self.data[:recoveries][db_name][i]['recoveryCompleteDate'] = Time.now.strftime('%d-%b-%Y %H:%M:%S UTC')
+                b = self.data[:backups][db_name][i]
+              end
+            end
+          }
+          response.body = {
+            'recoveryList' => recoveries
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/list_servers.rb

@@ -0,0 +1,27 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+      	def list_servers(db_name)
+          response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{db_name}/servers"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def list_servers(db_name)
+          response = Excon::Response.new
+
+          servers = self.data[:servers][db_name]
+
+          response.body = servers
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/list_snapshots.rb

@@ -0,0 +1,27 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+      	def list_snapshots(db_name)
+          response = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "/paas/api/v1.1/instancemgmt/#{@identity_domain}/services/dbaas/instances/#{db_name}/snapshots"
+          )
+          response
+        end
+      end
+
+      class Mock
+        def list_snapshots(db_name)
+          response = Excon::Response.new
+
+          snapshots = self.data[:snapshots][db_name].values
+
+          response.body = snapshots
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/recover_instance.rb

@@ -0,0 +1,80 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+      	def recover_instance(service_name, type=nil, value=nil)
+          if type == 'latest' then body_data = { 'latest' => true } end
+          if type == 'tag' then body_data = { 'tag' => value } end
+          if type == 'timestamp' then body_data = { 'timestamp' => value } end
+          if type == 'scn' then body_data = { 'scn' => value } end
+        
+          response = request(
+            :method   => 'POST',
+            :expects  => 202,
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{service_name}/backups/recovery",
+            :body     => Fog::JSON.encode(body_data),
+          )
+          response.database_id = service_name
+          response
+        end
+      end
+
+      class Mock
+        def recover_instance(service_name, type=nil, value=nil)
+      		response = Excon::Response.new
+
+          if !self.data[:recoveries][service_name].is_a? Array then 
+            self.data[:recoveries][service_name] = []
+            self.data[:created_at][:recoveries] = {}
+            self.data[:created_at][:recoveries][service_name] = []
+          end
+
+          # Find the backup first
+          backups = self.data[:backups][service_name]
+          backup = nil
+          if type == 'tag' then
+            backup = backups.find { |b| b['dbTag'] = value }
+          elsif type == 'timestamp' then
+            # Too hard to do this logic in mock. Just return the latest
+            backup = backups.last
+          elsif type.nil? then
+            # Default to searching for the latest
+            backup = backups.last
+          end
+          if backup.nil? then
+            response.status = 500
+          else
+            if type == 'tag' then
+              self.data[:recoveries][service_name].push({
+                'recoveryStartDate'=>Time.now.strftime('%d-%b-%Y %H:%M:%S UTC'),
+                'status'=>'IN PROGRESS',
+                'dbTag'=>value,
+                'database_id' => service_name
+              })
+              self.data[:created_at][:recoveries][service_name].push(Time.now)
+            elsif type == 'timestamp' then
+              self.data[:recoveries][service_name].push({
+                'recoveryStartDate'=>Time.now.strftime('%d-%b-%Y %H:%M:%S UTC'),
+                'status'=>'IN PROGRESS',
+                'timestamp'=>value.strftime('%d-%b-%Y %H:%M:%S'),
+                'database_id' => service_name
+              })
+              self.data[:created_at][:recoveries][service_name].push(Time.now)
+            elsif type.nil? then
+              self.data[:recoveries][service_name].push({
+                'recoveryStartDate'=>Time.now.strftime('%d-%b-%Y %H:%M:%S UTC'),
+                'status'=>'IN PROGRESS',
+                'latest'=>true,
+                'database_id' => service_name
+              })
+              self.data[:created_at][:recoveries][service_name].push(Time.now)
+            end
+            response.status = 202
+          end
+          response
+      	end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/requests/database/scale_instance.rb

@@ -0,0 +1,40 @@
+module Fog
+  module OracleCloud
+    class Database
+      class Real
+
+      	def scale_instance(name, options={})
+          body_data     = {
+            'shape'             => options[:shape],
+            'additionalStorage' => options[:additional_storage],
+            'usage'             => options[:usage]
+          }
+          body_data = body_data.reject {|key, value| value.nil?}
+        
+          request(
+            :method   => 'PUT',
+            :expects  => 202,
+            :path     => "/paas/service/dbcs/api/v1.1/instances/#{@identity_domain}/#{name}",
+            :body     => Fog::JSON.encode(body_data),
+          )
+        end
+      end
+
+      class Mock
+        def scale_instance(name, options={})
+      		response = Excon::Response.new
+
+          self.data[:instances][name]['status'] = 'Maintenance'
+          info = { 'time'=> Time.now }
+          if (options[:shape]) then
+            info['attribute'] = 'shape'
+            info['value'] = options[:shape]
+          end
+          self.data[:maintenance_at][name] = info
+          response.status = 202
+          response
+      	end
+      end
+    end
+  end
+end

data/lib/fog/oraclecloud/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module OracleCloud
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/tests/requests/database_tests.rb

@@ -22,7 +22,30 @@ Shindo.tests('Fog::Database[oraclecloud] | database requests', 'database') do
 
 		test "is built" do
 			db.ready?
+			db.shape == 'oc3'
 		end
+
+		test "scale up instance" do
+			db.scale('oc4')
+			db.wait_for { ready? }
+			db.shape == 'oc4'
+		end
+
+		test "can add extra storage" do
+			db.add_storage(1)
+			db.wait_for { ready? }
+			db.ready?
+		end
+
+		test "can expand storage" do
+			db.expand_storage(1)
+			db.wait_for { ready? }
+			db.ready?
+			db.expand_storage(1, 'backup')
+			db.wait_for { ready? }
+			db.ready?
+		end
+
 	end
 
 	tests('#database-read') do
@@ -43,6 +66,146 @@ Shindo.tests('Fog::Database[oraclecloud] | database requests', 'database') do
 		test "should return an instance" do
 			instance.service_name.is_a? String
 		end
+		servers = instance.servers
+		test "should have compute nodes" do
+			servers.is_a? Array
+			servers.size >= 1
+			servers.first.status.is_a? String
+		end
+	end
+
+	tests("#database-backups-create", "create") do
+		instance = Fog::OracleCloud[:database].instances.first
+		instance.backup()
+		test "backup created" do
+			backups = instance.backups
+			backups.is_a? Array
+			backups.first.wait_for { completed? }
+			backups.first.completed?
+		end
+	end
+
+	tests("#database-backups", "backups") do
+		instance = Fog::OracleCloud[:database].instances.first
+		backups = instance.backups
+		test "should have backups" do
+			backups.is_a? Array
+		end
+		if backups.size >= 1 then
+			test "one of them should have completed" do
+				backups.size >= 1
+				backups.first.completed?
+			end
+		end
+	end
+
+	tests("#database-recoveries-create", "create") do
+		instance = Fog::OracleCloud[:database].instances.first
+		tag = instance.backups.first.db_tag
+		instance.recover('tag', tag)
+		recoveries = instance.recoveries
+		test "can recover by tag" do
+			recoveries.is_a? Array
+			rec = recoveries.find {|r| r.db_tag == tag}
+			rec.is_a? Fog::OracleCloud::Database::Recovery
+			rec.wait_for { completed? }
+			rec.recovery_complete_date.is_a? String
+		end
+		test "can recover by latest" do
+			instance.recover_latest()
+			rec = instance.recoveries.find {|r| !r.latest.nil? }
+			rec.is_a? Fog::OracleCloud::Database::Recovery
+			rec.latest
+			rec.wait_for { completed? }
+			rec.recovery_complete_date.is_a? String			
+		end
+		test "can recover by timestamp" do
+			time = Time.now
+			instance.recover('timestamp', time)
+			rec = instance.recoveries.find {|r| !r.latest.nil? }
+			rec.is_a? Fog::OracleCloud::Database::Recovery
+			rec.timestamp == time
+			rec.wait_for { completed? }
+			rec.recovery_complete_date.is_a? String						
+		end
+		# Need to test SCN. Not sure how to mock test this?
+	end
+
+	tests("#database-recoveries", "recoveries") do
+		instances = Fog::OracleCloud[:database].instances
+		recs = Fog::OracleCloud[:database].recoveries.all(instances.first.service_name)
+		test "might have recoveries" do
+			recs.is_a? Array
+		end
+		if recs.size >= 1 then
+			test "one of them should have completed" do
+				recs.first.completed?
+			end
+		end
+	end
+
+	tests("#database-snapshots-create", "create") do
+		instances = Fog::OracleCloud[:database].instances
+
+		snap = Fog::OracleCloud[:database].snapshots.create(
+			:name => 'TestSnapshot',
+			:description => 'A new snapshot',
+			:database_id => instances.first.service_name
+		)
+		test "can create a snapshot" do
+			snap.is_a? Fog::OracleCloud::Database::Snapshot
+		end
+
+		test "is being built" do
+			!snap.completed?
+		end
+		snap.wait_for { completed? }
+
+		test "is built" do
+			snap.completed?
+		end
+	end
+
+	tests("#database-snapshots", "snapshots") do
+		instances = Fog::OracleCloud[:database].instances
+		snaps = instances.first.snapshots
+		test "might have snapshots" do
+			snaps.is_a? Array
+		end
+		if snaps.size >= 1 then
+			test "one of them should have completed" do
+				snaps.first.completed?
+			end
+			test "can get snapshot" do
+				snap = instances.first.get_snapshot(snaps.first.name)
+				snap.name.is_a? String
+				snap.cloned_services.is_a? Array
+				snap.cloned_services.first['clonedServiceName'].is_a? String
+			end
+		end
+	end
+
+	tests("#database-shapshots-delete", "create") do
+		db = Fog::OracleCloud[:database].instances.get('TestDB')
+		snap = db.snapshots.first
+		snap.destroy()
+		snap.wait_for { deleting? }
+		tests("should actually delete snapshot").raises(Fog::OracleCloud::Database::NotFound) do 
+			snap.wait_for { status == 'Stopped' }
+		end
+	end
+
+	tests("database-patches") do
+		instances = Fog::OracleCloud[:database].instances
+		patches = instances.first.patches
+		test "should have patches" do
+			patches.is_a? Array
+		end
+		if patches.size >= 1 then
+			test "has a patch id" do
+				patches.first.id.is_a? String
+			end
+		end
 	end
 
 	tests("#database-delete", "create") do
@@ -53,4 +216,6 @@ Shindo.tests('Fog::Database[oraclecloud] | database requests', 'database') do
 			db.wait_for { stopped? } 
 		end
 	end
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fog-oraclecloud
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Joel Nation
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-25 00:00:00.000000000 Z
+date: 2016-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -148,8 +148,18 @@ files:
 - lib/fog/oraclecloud/models/compute/ssh_keys.rb
 - lib/fog/oraclecloud/models/compute/volume.rb
 - lib/fog/oraclecloud/models/compute/volumes.rb
+- lib/fog/oraclecloud/models/database/backup.rb
+- lib/fog/oraclecloud/models/database/backups.rb
 - lib/fog/oraclecloud/models/database/instance.rb
 - lib/fog/oraclecloud/models/database/instances.rb
+- lib/fog/oraclecloud/models/database/patch.rb
+- lib/fog/oraclecloud/models/database/patches.rb
+- lib/fog/oraclecloud/models/database/recoveries.rb
+- lib/fog/oraclecloud/models/database/recovery.rb
+- lib/fog/oraclecloud/models/database/server.rb
+- lib/fog/oraclecloud/models/database/servers.rb
+- lib/fog/oraclecloud/models/database/snapshot.rb
+- lib/fog/oraclecloud/models/database/snapshots.rb
 - lib/fog/oraclecloud/models/java/instance.rb
 - lib/fog/oraclecloud/models/java/instances.rb
 - lib/fog/oraclecloud/models/java/server.rb
@@ -197,10 +207,21 @@ files:
 - lib/fog/oraclecloud/requests/compute/update_image_list.rb
 - lib/fog/oraclecloud/requests/compute/update_orchestration.rb
 - lib/fog/oraclecloud/requests/compute/update_ssh_key.rb
+- lib/fog/oraclecloud/requests/database/backup_instance.rb
 - lib/fog/oraclecloud/requests/database/create_instance.rb
+- lib/fog/oraclecloud/requests/database/create_snapshot.rb
 - lib/fog/oraclecloud/requests/database/delete_instance.rb
+- lib/fog/oraclecloud/requests/database/delete_snapshot.rb
 - lib/fog/oraclecloud/requests/database/get_instance.rb
+- lib/fog/oraclecloud/requests/database/get_snapshot.rb
+- lib/fog/oraclecloud/requests/database/list_backups.rb
 - lib/fog/oraclecloud/requests/database/list_instances.rb
+- lib/fog/oraclecloud/requests/database/list_patches.rb
+- lib/fog/oraclecloud/requests/database/list_recoveries.rb
+- lib/fog/oraclecloud/requests/database/list_servers.rb
+- lib/fog/oraclecloud/requests/database/list_snapshots.rb
+- lib/fog/oraclecloud/requests/database/recover_instance.rb
+- lib/fog/oraclecloud/requests/database/scale_instance.rb
 - lib/fog/oraclecloud/requests/java/create_instance.rb
 - lib/fog/oraclecloud/requests/java/delete_instance.rb
 - lib/fog/oraclecloud/requests/java/get_instance.rb