fog-google 0.6.0 → 1.0.0

data/lib/fog/compute/google/requests/remove_target_pool_health_checks.rb

@@ -2,24 +2,25 @@ module Fog
   module Compute
     class Google
       class Mock
-        def remove_target_pool_health_checks(_target_pool, _health_checks)
+        def remove_target_pool_health_checks(_target_pool, _region, _health_checks)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def remove_target_pool_health_checks(target_pool, health_checks)
-          api_method = @compute.target_pools.remove_health_check
-          parameters = {
-            "project" => @project,
-            "targetPool" => target_pool.name,
-            "region" => target_pool.region.split("/")[-1]
-          }
-          body = {
-            "healthChecks" => health_checks.map { |i| { "healthCheck" => i } }
-          }
+        def remove_target_pool_health_checks(target_pool, region, health_checks)
+          health_check_lst = health_checks.map do |hc|
+            ::Google::Apis::ComputeV1::HealthCheckReference.new(:health_check => hc)
+          end
 
-          request(api_method, parameters, body_object = body)
+          @compute.remove_target_pool_health_check(
+            @project,
+            region.split("/")[-1],
+            target_pool,
+            ::Google::Apis::ComputeV1::RemoveTargetPoolsHealthCheckRequest.new(
+              :health_checks => health_check_lst
+            )
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/remove_target_pool_instance.rb

@@ -2,24 +2,25 @@ module Fog
   module Compute
     class Google
       class Mock
-        def set_metadata(_instance, _zone, _fingerprint, _metadata = {})
+        def remove_target_pool_instances(_target_pool, _region, _instances)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def remove_target_pool_instances(target_pool, instances)
-          api_method = @compute.target_pools.remove_instance
-          parameters = {
-            "project" => @project,
-            "targetPool" => target_pool.name,
-            "region" => target_pool.region.split("/")[-1]
-          }
-          body = {
-            "instances" => instances.map { |i| { "instance" => i } }
-          }
+        def remove_target_pool_instances(target_pool, region, instances)
+          instance_lst = instances.map do |instance|
+            ::Google::Apis::ComputeV1::InstanceReference.new(:instance => instance)
+          end
 
-          request(api_method, parameters, body_object = body)
+          @compute.remove_target_pool_instance(
+            @project,
+            region.split("/")[-1],
+            target_pool,
+            ::Google::Apis::ComputeV1::RemoveTargetPoolsInstanceRequest.new(
+              :instances => instance_lst
+            )
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/remove_target_pool_instances.rb

@@ -2,24 +2,25 @@ module Fog
   module Compute
     class Google
       class Mock
-        def remove_target_pool_instances(_target_pool, _instances)
+        def remove_target_pool_instances(_target_pool, _region, _instances)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def remove_target_pool_instances(target_pool, instances)
-          api_method = @compute.target_pools.remove_instance
-          parameters = {
-            "project" => @project,
-            "targetPool" => target_pool.name,
-            "region" => target_pool.region.split("/")[-1]
-          }
-          body = {
-            "instances" => instances.map { |i| { "instance" => i } }
-          }
+        def remove_target_pool_instances(target_pool, region, instances)
+          instance_lst = instances.map do |link|
+            ::Google::Apis::ComputeV1::InstanceReference.new(
+              :instance => link
+            )
+          end
 
-          request(api_method, parameters, body_object = body)
+          @compute.remove_target_pool_instance(
+            @project, region.split("/")[-1], target_pool,
+            ::Google::Apis::ComputeV1::RemoveTargetPoolsInstanceRequest.new(
+              :instances => instance_lst
+            )
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/reset_server.rb

@@ -9,14 +9,7 @@ module Fog
 
       class Real
         def reset_server(identity, zone)
-          api_method = @compute.instances.reset
-          parameters = {
-            "project"  => @project,
-            "instance" => identity,
-            "zone"     => zone.split("/")[-1]
-          }
-
-          request(api_method, parameters)
+          @compute.reset_instance(@project, zone.split("/")[-1], identity)
         end
       end
     end

data/lib/fog/compute/google/requests/set_common_instance_metadata.rb

@@ -2,23 +2,18 @@ module Fog
   module Compute
     class Google
       class Mock
-        def set_common_instance_metadata(_identity, _current_fingerprint, _metadata = {})
+        def set_common_instance_metadata(_project, _current_fingerprint, _metadata = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def set_common_instance_metadata(identity, current_fingerprint, metadata = {})
-          api_method = @compute.projects.set_common_instance_metadata
-          parameters = {
-            :project => identity
-          }
-          body_object = {
+        def set_common_instance_metadata(project, current_fingerprint, metadata = {})
+          metadata_obj = ::Google::Apis::ComputeV1::Metadata.new(
             :fingerprint => current_fingerprint,
-            :items => Array(metadata).map { |pair| { :key => pair[0], :value => pair[1] } }
-          }
-
-          request(api_method, parameters, body_object)
+            :items => metadata.map { |k, v| { :key => k, :value => v } }
+          )
+          @compute.set_common_instance_metadata(project, metadata_obj)
         end
       end
     end

data/lib/fog/compute/google/requests/set_forwarding_rule_target.rb

@@ -2,24 +2,18 @@ module Fog
   module Compute
     class Google
       class Mock
-        def set_forwarding_rule_target(_rule, _target)
+        def set_forwarding_rule_target(_rule_name, _region, _target_opts)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def set_forwarding_rule_target(rule, target)
-          api_method = @compute.forwarding_rules.set_target
-          parameters = {
-            "project" => @project,
-            "forwardingRule" => rule.name,
-            "region" => rule.region.split("/")[-1]
-          }
-          body = {
-            "target" => target
-          }
-
-          request(api_method, parameters, body_object = body)
+        def set_forwarding_rule_target(rule_name, region, target_opts)
+          region = region.split("/")[-1] if region.start_with? "http"
+          @compute.set_forwarding_rule_target(
+            @project, region, rule_name,
+            ::Google::Apis::ComputeV1::TargetReference.new(target_opts)
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/set_global_forwarding_rule_target.rb

@@ -2,24 +2,17 @@ module Fog
   module Compute
     class Google
       class Mock
-        def set_global_forwarding_rule_target(_rule, _target)
+        def set_global_forwarding_rule_target(_rule_name, _target)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def set_global_forwarding_rule_target(rule, target)
-          api_method = @compute.global_forwarding_rules.set_target
-          parameters = {
-            "project" => @project,
-            "forwardingRule" => rule.name,
-            "region" => "global"
-          }
-          body = {
-            "target" => target
-          }
-
-          request(api_method, parameters, body_object = body)
+        def set_global_forwarding_rule_target(rule_name, target_opts)
+          @compute.set_global_forwarding_rule_target(
+            @project, rule_name,
+            ::Google::Apis::ComputeV1::TargetReference.new(target_opts)
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/set_server_disk_auto_delete.rb

@@ -8,17 +8,15 @@ module Fog
       end
 
       class Real
+        # @see https://cloud.google.com/compute/docs/reference/latest/instances/setDiskAutoDelete
         def set_server_disk_auto_delete(identity, zone, auto_delete, device_name)
-          api_method = @compute.instances.set_disk_auto_delete
-          parameters = {
-            "project"    => @project,
-            "instance"   => identity,
-            "zone"       => zone.split("/")[-1],
-            "autoDelete" => auto_delete,
-            "deviceName" => device_name
-          }
-
-          request(api_method, parameters)
+          @compute.set_disk_auto_delete(
+            @project,
+            zone.split("/")[-1],
+            identity,
+            auto_delete,
+            device_name
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/set_server_metadata.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_metadata(_instance, _zone, _fingerprint, _metadata_items = {})
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        # Set an instance metadata
+        #
+        # @param [String] instance Instance name (identity)
+        # @param [String] zone Name of zone
+        # @param [String] fingerprint The fingerprint of the last metadata.
+        #   Can be retrieved by reloading the compute object, and checking the
+        #   metadata fingerprint field.
+        #     instance.reload
+        #     fingerprint = instance.metadata['fingerprint']
+        # @param [Hash] metadata A new metadata object
+        #
+        # @returns [::Google::Apis::ComputeV1::Operation] set operation
+        def set_server_metadata(instance, zone, fingerprint, metadata_items = [])
+          items = metadata_items.map { |item| ::Google::Apis::ComputeV1::Metadata::Item.new(item) }
+          @compute.set_instance_metadata(
+            @project, zone.split("/")[-1], instance,
+            ::Google::Apis::ComputeV1::Metadata.new(
+              :fingerprint => fingerprint, :items => items
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_server_scheduling.rb

@@ -8,21 +8,13 @@ module Fog
       end
 
       class Real
-        def set_server_scheduling(identity, zone, on_host_maintenance, automatic_restart, preemptible)
-          api_method = @compute.instances.set_scheduling
-          parameters = {
-            "project"  => @project,
-            "instance" => identity,
-            "zone"     => zone.split("/")[-1]
-          }
-
-          body_object = {
-            "onHostMaintenance" => on_host_maintenance,
-            "automaticRestart"  => automatic_restart,
-            "preemptible" => preemptible
-          }
-
-          request(api_method, parameters, body_object)
+        def set_server_scheduling(identity, zone, on_host_maintenance: nil, automatic_restart: nil, preemptible: nil)
+          scheduling = ::Google::Apis::ComputeV1::Scheduling.new
+          scheduling.on_host_maintenance = on_host_maintenance unless on_host_maintenance.nil?
+          scheduling.automatic_restart = automatic_restart unless automatic_restart.nil?
+          scheduling.preemptible = preemptible unless preemptible.nil?
+          zone = zone.split("/")[-1]
+          @compute.set_instance_scheduling(@project, zone, identity, scheduling)
         end
       end
     end

data/lib/fog/compute/google/requests/set_server_tags.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_tags(_instance, _zone, _tags = [])
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def set_server_tags(instance, zone, fingerprint, tags = [])
+          @compute.set_instance_tags(
+            @project, zone.split("/")[-1], instance,
+            ::Google::Apis::ComputeV1::Tags.new(
+              :fingerprint => fingerprint,
+              :items => tags
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_snapshot_labels.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_snapshot_labels(_snap_name)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def set_snapshot_labels(snap_name, label_fingerprint, labels)
+          @compute.set_snapshot_labels(
+            project, snap_name,
+            ::Google::Apis::ComputeV1::GlobalSetLabelsRequest.new(
+              :label_fingerprint => label_fingerprint,
+              :labels => labels
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_subnetwork_private_ip_google_access.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_subnetwork_private_ip_google_access(_subnetwork_name,
+                                                    _region_name,
+                                                    _private_ip_google_access)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        ##
+        # Set whether VMs in this subnet can access Google services without
+        # assigning external IP addresses through Private Google Access.
+        #
+        # @param subnetwork_name [String] the name of the subnetwork
+        # @param region_name [String] the name of the subnetwork's region
+        # @param private_ip_google_access [Boolean] whether
+        #   private ip google access should be enforced
+        # @return [Google::Apis::ComputeV1::Operation] an operation response
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/subnetworks/setPrivateIpGoogleAccess
+        def set_subnetwork_private_ip_google_access(subnetwork_name,
+                                                    region_name,
+                                                    private_ip_google_access)
+          if region_name.start_with? "http"
+            region_name = region_name.split("/")[-1]
+          end
+          @compute.set_subnetwork_private_ip_google_access(
+            @project, region_name, subnetwork_name,
+            ::Google::Apis::ComputeV1::SubnetworksSetPrivateIpGoogleAccessRequest.new(
+              :private_ip_google_access => private_ip_google_access
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_target_http_proxy_url_map.rb

@@ -2,24 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def set_target_http_proxy_url_map(_target_http_proxy, _url_map)
+        def set_target_http_proxy_url_map(_proxy_name, _url_map)
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def set_target_http_proxy_url_map(target_http_proxy, url_map)
-          api_method = @compute.target_http_proxies.set_url_map
-          parameters = {
-            "project" => @project,
-            "targetHttpProxy" => target_http_proxy.name
-          }
-          url_map = url_map.self_link unless url_map.class == String
-          body = {
-            "urlMap" => url_map
-          }
-
-          request(api_method, parameters, body_object = body)
+        def set_target_http_proxy_url_map(proxy_name, url_map)
+          @compute.set_target_http_proxy_url_map(
+            @project, proxy_name,
+            ::Google::Apis::ComputeV1::UrlMapReference.new(
+              :url_map => url_map.class == String ? url_map : url_map.self_link
+            )
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/set_target_https_proxy_ssl_certificates.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_target_https_proxy_ssl_certificates(_proxy_name, _certs)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def set_target_https_proxy_ssl_certificates(proxy_name, certs)
+          @compute.set_target_https_proxy_ssl_certificates(
+            @project, proxy_name,
+            ::Google::Apis::ComputeV1::TargetHttpsProxiesSetSslCertificatesRequest.new(
+              :ssl_certificates => certs
+            )
+          )
+        end
+      end
+    end
+  end
+end