fog-google 0.6.0 → 1.0.0

data/lib/fog/compute/google/models/url_map.rb

@@ -4,69 +4,99 @@ module Fog
       class UrlMap < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :default_service, :aliases => "defaultService"
         attribute :description, :aliases => "description"
         attribute :fingerprint, :aliases => "fingerprint"
         attribute :host_rules, :aliases => "hostRules"
         attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
         attribute :path_matchers, :aliases => "pathMatchers"
         attribute :self_link, :aliases => "selfLink"
         attribute :tests, :aliases => "tests"
 
         def save
-          requires :name, :default_service
+          requires :identity, :default_service
 
           options = {
-            "defaultService" => default_service,
-            "description" => description,
-            "fingerprint" => fingerprint,
-            "hostRules" => host_rules,
-            "pathMatchers" => path_matchers,
-            "tests" => tests
+            :default_service => default_service,
+            :description => description,
+            :fingerprint => fingerprint,
+            :host_rules => host_rules,
+            :path_matchers => path_matchers,
+            :tests => tests
           }
 
-          data = service.insert_url_map(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"])
+          # Update if creation_timestamp is set, create url map otherwise.
+          data = nil
+          if creation_timestamp
+            data = service.update_url_map(identity, options)
+          else
+            data = service.insert_url_map(identity, options)
+          end
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
 
         def destroy(async = true)
-          requires :name
+          requires :identity
 
-          operation = service.delete_url_map(name)
-          unless async
-            Fog.wait_for do
-              operation = service.get_global_operation(operation.body["name"])
-              operation.body["status"] == "DONE"
-            end
-          end
+          data = service.delete_url_map(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def validate
-          service.validate_url_map self
+          requires :identity
+          service.validate_url_map(identity, attributes)
         end
 
-        def add_host_rules(hostRules)
-          hostRules = [hostRules] unless hostRules.class == Array
-          service.update_url_map(self, hostRules)
+        def add_host_rules(rules_to_add, async = true)
+          requires :identity
+
+          rules = (host_rules || []).concat rules_to_add
+          data = service.patch_url_map(identity, :host_rules => rules)
+
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           reload
         end
 
-        def add_path_matchers(pathMatchers, hostRules)
-          pathMatchers = [pathMatchers] unless pathMatchers.class == Array
-          hostRules = [hostRules] unless hostRules.class == Array
-          service.update_url_map(self, hostRules, pathMatchers)
+        def add_path_matchers(matchers_to_add, rules_to_add, async = true)
+          requires :identity
+
+          matchers = (path_matchers || []) + matchers_to_add
+          rules = (host_rules || []) + rules_to_add
+          data = service.patch_url_map(identity,
+                                       :host_rules => rules,
+                                       :path_matchers => matchers)
+
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           reload
         end
 
+        def invalidate_cache(path, host = nil, async = true)
+          requires :identity
+
+          data = service.invalidate_url_map_cache(identity, path, host)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
         def ready?
           service.get_url_map(name)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -84,7 +114,7 @@ module Fog
           self
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

data/lib/fog/compute/google/models/url_maps.rb

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::UrlMap
 
         def all
-          data = service.list_url_maps.body["items"] || []
+          data = service.list_url_maps.to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          if url_map = service.get_url_map(identity).body
+          if url_map = service.get_url_map(identity).to_h
             new(url_map)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

data/lib/fog/compute/google/models/zone.rb

@@ -3,17 +3,21 @@ module Fog
     class Google
       class Zone < Fog::Model
         identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :deprecated
         attribute :description
-        attribute :status
-        attribute :maintenance_windows, :aliases => "maintenanceWindows"
-        attribute :begin_time, :aliases => "beginTime"
-        attribute :end_time, :aliases => "endTime"
-        attribute :quotas
+        attribute :id
+        attribute :kind
         attribute :region
         attribute :self_link, :aliases => "selfLink"
+        attribute :status
+
+        UP_STATE = "UP".freeze
+        DOWN_STATE = "DOWN".freeze
 
         def up?
-          status == "UP"
+          status == UP_STATE
         end
       end
     end

data/lib/fog/compute/google/models/zones.rb

@@ -5,14 +5,15 @@ module Fog
         model Fog::Compute::Google::Zone
 
         def all
-          data = service.list_zones.body["items"] || []
+          data = service.list_zones.to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          data = service.get_zone(identity).body
+          data = service.get_zone(identity).to_h
           new(data)
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

data/lib/fog/compute/google/real.rb

@@ -11,9 +11,8 @@ module Fog
           shared_initialize(options[:google_project], GOOGLE_COMPUTE_API_VERSION, GOOGLE_COMPUTE_BASE_URL)
           options[:google_api_scope_url] = GOOGLE_COMPUTE_API_SCOPE_URLS.join(" ")
 
-          @client = initialize_google_client(options)
-          @compute = @client.discovered_api("compute", api_version)
-          @resourceviews = @client.discovered_api("resourceviews", "v1beta1")
+          initialize_google_client(options)
+          @compute = ::Google::Apis::ComputeV1::ComputeService.new
           @extra_global_projects = options[:google_extra_global_projects] || []
         end
       end

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

@@ -8,20 +8,8 @@ module Fog
       end
 
       class Real
-        def add_backend_service_backends(backend_service, new_backends)
-          api_method = @compute.backend_services.patch
-          parameters = {
-            "project" => @project,
-            "backendService" => backend_service.name
-          }
-          if backend_service.backends
-            backend_service.backends.concat(new_backends)
-          else
-            backend_service.backends = new_backends
-          end
-          body_object = backend_service
-
-          request(api_method, parameters, body_object)
+        def add_backend_service_backends(backend_service, _new_backends)
+          @compute.patch_backend_service(@project, backend_service.name, backend_service)
         end
       end
     end

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

@@ -9,27 +9,25 @@ module Fog
 
       class Real
         def add_instance_group_instances(group_name, zone, instances)
-          api_method = @compute.instance_groups.add_instances
-
-          parameters = {
-            "project" => @project,
-            "instanceGroup" => group_name,
-            "zone" => zone
-          }
-
           instances.map! do |instance|
             if instance.start_with?("https:")
-              { "instance" => instance }
+              ::Google::Apis::ComputeV1::InstanceReference.new(:instance => instance)
             else
-              { "instance" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/instances/#{instance}\n" }
+              ::Google::Apis::ComputeV1::InstanceReference.new(
+                :instance => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/instances/#{instance}\n"
+              )
             end
           end
 
-          body_object = {
-            "instances" => instances
-          }
-
-          request(api_method, parameters, body_object)
+          request = ::Google::Apis::ComputeV1::InstanceGroupsAddInstancesRequest.new(
+            :instances => instances
+          )
+          @compute.add_instance_group_instances(
+            @project,
+            zone,
+            group_name,
+            request
+          )
         end
       end
     end

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

@@ -8,23 +8,21 @@ module Fog
       end
 
       class Real
-        def add_server_access_config(identity, zone, nic, options = {})
-          api_method = @compute.instances.add_access_config
-          parameters = {
-            "project"  => @project,
-            "instance" => identity,
-            "zone"     => zone.split("/")[-1],
-            "networkInterface" => nic
-          }
-
-          body_object = {
-            "type" => "ONE_TO_ONE_NAT"
-          }
-
-          body_object["name"] = options[:name] ? options[:name] : "External NAT"
-          body_object["natIP"] = options[:address] if options[:address]
-
-          request(api_method, parameters, body_object)
+        def add_server_access_config(identity, zone,
+                                     network_interface,
+                                     access_config_name = "External NAT",
+                                     nat_ip: nil)
+          @compute.add_instance_access_config(
+            @project,
+            zone.split("/")[-1],
+            identity,
+            network_interface,
+            ::Google::Apis::ComputeV1::AccessConfig.new(
+              :name => access_config_name,
+              :nat_ip => nat_ip,
+              :type => "ONE_TO_ONE_NAT"
+            )
+          )
         end
       end
     end

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

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

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

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

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

@@ -2,31 +2,17 @@ module Fog
   module Compute
     class Google
       class Mock
-        def attach_disk(_instance, _zone, _source, _options = {})
+        def attach_disk(_instance, _zone, _disk = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def attach_disk(instance, zone, source, options = {})
-          api_method = @compute.instances.attach_disk
-          parameters = {
-            "project" => @project,
-            "instance" => instance,
-            "zone" => zone.split("/")[-1]
-          }
-
-          writable = options.delete(:writable)
-          body_object = {
-            "type" =>       "PERSISTENT",
-            "source" =>     source,
-            "mode" =>       writable ? "READ_WRITE" : "READ_ONLY",
-            "deviceName" => options.delete(:deviceName),
-            "boot" =>       options.delete(:boot),
-            "autoDelete" => options.delete(:autoDelete)
-          }
-
-          request(api_method, parameters, body_object)
+        def attach_disk(instance, zone, disk = {})
+          @compute.attach_disk(
+            @project, zone.split("/")[-1], instance,
+            ::Google::Apis::ComputeV1::AttachedDisk.new(disk)
+          )
         end
       end
     end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def create_disk_snapshot(_snapshot_name, _disk, _zone, _snapshot = {})
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def create_disk_snapshot(snapshot_name, disk, zone, snapshot = {})
+          @compute.create_disk_snapshot(
+            @project, zone, disk,
+            ::Google::Apis::ComputeV1::Snapshot.new(
+              snapshot.merge(:name => snapshot_name)
+            )
+          )
+        end
+      end
+    end
+  end
+end