fog-google 0.6.0 → 1.0.0

data/lib/fog/google/requests/sql/clone_instance.rb

@@ -4,79 +4,35 @@ module Fog
       ##
       # Creates a Cloud SQL instance as a clone of the source instance
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/instances/clone
-
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/instances/clone
       class Real
-        def clone_instance(instance_id, destination_name, options = {})
-          # The @sql.instances.clone method is overrided by the standard Ruby clone method
-          # so we cannot call it because it will just clone the @sql.instances instance.
-          # Instead we need to find the proper method trough the discovered_methods.
-          api_method = @sql.instances.discovered_methods.detect { |x| x.id == "sql.instances.clone" }
-          parameters = {
-            "project" => @project
-          }
-
-          body = {
-            "cloneContext" => {
-              "kind" => 'sql#cloneContext',
-              "sourceInstanceName" => instance_id,
-              "destinationInstanceName" => destination_name
-            }
+        def clone_instance(instance_id, destination_name,
+                           log_filename: nil, log_position: nil)
+          context = {
+            :kind => "sql#cloneContext",
+            :destination_instance_name => destination_name
           }
 
-          if options[:log_position]
-            body["cloneContext"]["binLogCoordinates"] = {
-              "kind" => 'sql#binLogCoordinates',
-              "binLogFileName" => options[:log_filename],
-              "binLogPosition" => options[:log_position]
-            }
+          unless log_filename.nil? || log_position.nil?
+            context[:bin_log_coordinates] = ::Google::Apis::SqladminV1beta4::BinLogCoordinates.new(
+              :kind => "sql#binLogCoordinates",
+              :log_filename => log_filename,
+              :log_position => log_position
+            )
           end
 
-          request(api_method, parameters, body)
+          clone_request = ::Google::Apis::SqladminV1beta4::CloneInstancesRequest.new(
+            :clone_context => ::Google::Apis::SqladminV1beta4::CloneContext.new(context)
+          )
+
+          @sql.clone_instance(@project, instance_id, clone_request)
         end
       end
 
       class Mock
-        def clone_instance(instance_id, destination_name, _options = {})
-          data[:instances][destination_name] = data[:instances][instance_id]
-          data[:instances][destination_name]["instance"] = destination_name
-          data[:ssl_certs][destination_name] = {}
-          data[:backup_runs][destination_name] = {}
-
-          operation = random_operation
-          data[:operations][destination_name] ||= {}
-          data[:operations][destination_name][operation] = {
-            "kind" => 'sql#instanceOperation',
-            "instance" => destination_name,
-            "operation" => operation,
-            "operationType" => "CREATE",
-            "state" => Fog::Google::SQL::Operation::DONE_STATE,
-            "userEmailAddress" => "google_client_email@developer.gserviceaccount.com",
-            "enqueuedTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "endTime" => Time.now.iso8601
-          }
-
-          operation = random_operation
-          data[:operations][instance_id] ||= {}
-          data[:operations][instance_id][operation] = {
-            "kind" => 'sql#instanceOperation',
-            "instance" => instance_id,
-            "operation" => operation,
-            "operationType" => "CLONE",
-            "state" => Fog::Google::SQL::Operation::DONE_STATE,
-            "userEmailAddress" => "google_client_email@developer.gserviceaccount.com",
-            "enqueuedTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "endTime" => Time.now.iso8601
-          }
-
-          body = {
-            "kind" => 'sql#instancesClone',
-            "operation" => operation
-          }
-
-          build_excon_response(body)
+        def clone_instance(_instance_id, _destination_name,
+                           _log_filename: nil, _log_position: nil)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/google/requests/sql/delete_backup_run.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Google
+    class SQL
+      ##
+      # Deletes the backup taken by a backup run.
+      #
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/backupRuns/delete
+      class Real
+        def delete_backup_run(instance_id, backup_run_id)
+          @sql.delete_backup_run(@project, instance_id, backup_run_id)
+        end
+      end
+
+      class Mock
+        def delete_backup_run(_instance_id, _run)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/sql/delete_instance.rb

@@ -4,62 +4,17 @@ module Fog
       ##
       # Deletes a Cloud SQL instance
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/instances/delete
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/instances/delete
 
       class Real
         def delete_instance(instance_id)
-          api_method = @sql.instances.delete
-          parameters = {
-            "project" => @project,
-            "instance" => instance_id
-          }
-
-          request(api_method, parameters)
+          @sql.delete_instance(@project, instance_id)
         end
       end
 
       class Mock
-        def delete_instance(instance_id)
-          if data[:instances].key?(instance_id)
-            data[:instances].delete(instance_id)
-            data[:ssl_certs].delete(instance_id)
-            data[:backup_runs].delete(instance_id)
-
-            operation = random_operation
-            data[:operations][instance_id] ||= {}
-            data[:operations][instance_id][operation] = {
-              "kind" => 'sql#instanceOperation',
-              "instance" => instance_id,
-              "operation" => operation,
-              "operationType" => "DELETE",
-              "state" => Fog::Google::SQL::Operation::PENDING_STATE,
-              "userEmailAddress" => "google_client_email@developer.gserviceaccount.com",
-              "enqueuedTime" => Time.now.iso8601
-            }
-
-            body = {
-              "kind" => 'sql#instancesDelete',
-              "operation" => operation
-            }
-            status = 200
-          else
-            body = {
-              "error" => {
-                "errors" => [
-                  {
-                    "domain" => "global",
-                    "reason" => "notAuthorized",
-                    "message" => "The client is not authorized to make this request."
-                  }
-                ],
-                "code" => 403,
-                "message" => "The client is not authorized to make this request."
-              }
-            }
-            status = 403
-          end
-
-          build_excon_response(body, status)
+        def delete_instance(_instance_id)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/google/requests/sql/delete_ssl_cert.rb

@@ -4,63 +4,17 @@ module Fog
       ##
       # Deletes a SSL certificate. The change will not take effect until the instance is restarted.
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/sslCerts/delete
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/sslCerts/delete
 
       class Real
         def delete_ssl_cert(instance_id, sha1_fingerprint)
-          api_method = @sql.ssl_certs.delete
-          parameters = {
-            "project" => @project,
-            "instance" => instance_id,
-            "sha1Fingerprint" => sha1_fingerprint
-          }
-
-          request(api_method, parameters)
+          @sql.delete_ssl_cert(@project, instance_id, sha1_fingerprint)
         end
       end
 
       class Mock
-        def delete_ssl_cert(instance_id, sha1_fingerprint)
-          if data[:ssl_certs].key?(instance_id)
-            data[:ssl_certs][instance_id].delete(sha1_fingerprint)
-
-            operation = random_operation
-            data[:operations][instance_id] ||= {}
-            data[:operations][instance_id][operation] = {
-              "kind" => 'sql#instanceOperation',
-              "instance" => instance_id,
-              "operation" => operation,
-              "operationType" => "UPDATE",
-              "state" => Fog::Google::SQL::Operation::DONE_STATE,
-              "userEmailAddress" => "google_client_email@developer.gserviceaccount.com",
-              "enqueuedTime" => Time.now.iso8601,
-              "startTime" => Time.now.iso8601,
-              "endTime" => Time.now.iso8601
-            }
-
-            body = {
-              "kind" => 'sql#sslCertsDelete',
-              "operation" => operation
-            }
-            status = 200
-          else
-            body = {
-              "error" => {
-                "errors" => [
-                  {
-                    "domain" => "global",
-                    "reason" => "notAuthorized",
-                    "message" => "The client is not authorized to make this request."
-                  }
-                ],
-                "code" => 403,
-                "message" => "The client is not authorized to make this request."
-              }
-            }
-            status = 403
-          end
-
-          build_excon_response(body, status)
+        def delete_ssl_cert(_instance_id, _sha1_fingerprint)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/google/requests/sql/delete_user.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Google
+    class SQL
+      ##
+      # Deletes a user from a Cloud SQL instance.
+      #
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/users/delete
+
+      class Real
+        def delete_user(instance_id, host, name)
+          @sql.delete_user(@project, instance_id, host, name)
+        end
+      end
+
+      class Mock
+        def delete_user(_instance_id, _host, _name)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/sql/export_instance.rb

@@ -2,53 +2,50 @@ module Fog
   module Google
     class SQL
       ##
-      # Exports data from a Cloud SQL instance to a Google Cloud Storage bucket as a MySQL dump file
+      # Exports data from a Cloud SQL instance to a Google Cloud Storage
+      # bucket as a MySQL dump or CSV file.
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/instances/export
-
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/instances/export
       class Real
-        def export_instance(instance_id, uri, options = {})
-          api_method = @sql.instances.export
-          parameters = {
-            "project" => @project,
-            "instance" => instance_id
+        def export_instance(instance_id, uri,
+                            databases: [],
+                            sql_export_options: {},
+                            csv_export_options: {},
+                            file_type: nil)
+          data = {
+            :kind => "sql#exportContext",
+            :uri => uri,
+            :databases => databases
           }
 
-          body = {
-            "exportContext" => {
-              "kind" => 'sql#exportContext',
-              "uri" => uri,
-              "database" => Array(options[:databases]),
-              "table" => Array(options[:tables])
-            }
-          }
+          unless file_type.nil?
+            data[:file_type] = file_type
+          end
+
+          unless csv_export_options.empty?
+            data[:csv_export_options] =
+              ::Google::Apis::SqladminV1beta4::ExportContext::CsvExportOptions.new(csv_export_options)
+          end
+
+          unless sql_export_options.nil?
+            data[:sql_export_options] =
+              ::Google::Apis::SqladminV1beta4::ExportContext::SqlExportOptions.new(sql_export_options)
+          end
 
-          request(api_method, parameters, body)
+          export_context = ::Google::Apis::SqladminV1beta4::ExportContext.new(export_context)
+          @sql.export_instance(
+            @project,
+            instance_id,
+            ::Google::Apis::SqladminV1beta4::ExportInstancesRequest.new(
+              :export_context => export_context
+            )
+          )
         end
       end
 
       class Mock
-        def export_instance(instance_id, _uri, _options = {})
-          operation = random_operation
-          data[:operations][instance_id] ||= {}
-          data[:operations][instance_id][operation] = {
-            "kind" => 'sql#instanceOperation',
-            "instance" => instance_id,
-            "operation" => operation,
-            "operationType" => "EXPORT",
-            "state" => Fog::Google::SQL::Operation::DONE_STATE,
-            "userEmailAddress" => "google_client_email@developer.gserviceaccount.com",
-            "enqueuedTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "endTime" => Time.now.iso8601
-          }
-
-          body = {
-            "kind" => 'sql#instancesExport',
-            "operation" => operation
-          }
-
-          build_excon_response(body)
+        def export_instance(_instance_id, _uri, _options: {})
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/google/requests/sql/get_backup_run.rb

@@ -2,26 +2,17 @@ module Fog
   module Google
     class SQL
       ##
-      # Retrieves a resource containing information about a backup run
+      # Retrieves a resource containing information about a backup run.
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/backupRuns/get
-
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/backupRuns/get
       class Real
-        def get_backup_run(instance_id, backup_configuration_id, due_time)
-          api_method = @sql.backup_runs.get
-          parameters = {
-            "project" => @project,
-            "instance" => instance_id,
-            "backupConfiguration" => backup_configuration_id,
-            "dueTime" => due_time
-          }
-
-          request(api_method, parameters)
+        def get_backup_run(instance_id, backup_run_id)
+          @sql.get_backup_run(@project, instance_id, backup_run_id)
         end
       end
 
       class Mock
-        def get_backup_run(_instance_id, _backup_configuration_id, _due_time)
+        def get_backup_run(_instance_id, _backup_run_id, _due_time)
           Fog::Mock.not_implemented
         end
       end

data/lib/fog/google/requests/sql/get_instance.rb

@@ -4,43 +4,17 @@ module Fog
       ##
       # Retrieves a resource containing information about a Cloud SQL instance
       #
-      # @see https://developers.google.com/cloud-sql/docs/admin-api/v1beta3/instances/get
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/instances/get
 
       class Real
         def get_instance(instance_id)
-          api_method = @sql.instances.get
-          parameters = {
-            "project" => @project,
-            "instance" => instance_id
-          }
-
-          request(api_method, parameters)
+          @sql.get_instance(@project, instance_id)
         end
       end
 
       class Mock
-        def get_instance(instance_id)
-          if data[:instances].key?(instance_id)
-            body = data[:instances][instance_id]
-            status = 200
-          else
-            body = {
-              "error" => {
-                "errors" => [
-                  {
-                    "domain" => "global",
-                    "reason" => "notAuthorized",
-                    "message" => "The client is not authorized to make this request."
-                  }
-                ],
-                "code" => 403,
-                "message" => "The client is not authorized to make this request."
-              }
-            }
-            status = 403
-          end
-
-          build_excon_response(body, status)
+        def get_instance(_instance_id)
+          Fog::Mock.not_implemented
         end
       end
     end