fog-google 0.6.0 → 1.0.0

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

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::TargetHttpsProxy
 
         def all(_filters = {})
-          data = service.list_target_https_proxies.body["items"] || []
+          data = service.list_target_https_proxies.to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          if target_https_proxy = service.get_target_https_proxy(identity).body
+          if target_https_proxy = service.get_target_https_proxy(identity).to_h
             new(target_https_proxy)
           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/target_https_proxy.rb

@@ -4,59 +4,78 @@ module Fog
       class TargetHttpsProxy < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description, :aliases => "description"
+        attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
+        attribute :self_link, :aliases => "selfLink"
         attribute :url_map, :aliases => "urlMap"
         attribute :ssl_certificates, :aliases => "sslCertificates"
 
         def save
-          requires :name
+          requires :identity, :url_map, :ssl_certificates
 
-          options = {
-            "description" => description,
-            "urlMap" => url_map,
-            "sslCertificates" => ssl_certificates
-          }
-
-          data = service.insert_target_https_proxy(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"])
+          data = service.insert_target_https_proxy(
+            identity,
+            :description => description,
+            :url_map => url_map,
+            :ssl_certificates => ssl_certificates
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
 
         def destroy(async = true)
-          requires :name
-          operation = service.delete_target_https_proxy(name)
-          unless async
-            # wait until "DONE" to ensure the operation doesn't fail, raises
-            # exception on error
-            Fog.wait_for do
-              operation.body["status"] == "DONE"
-            end
-          end
+          requires :identity
+
+          data = service.delete_target_https_proxy(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           operation
         end
 
-        def set_url_map(url_map)
-          service.set_target_https_proxy_url_map(self, url_map)
+        def set_url_map(url_map, async = true)
+          requires :identity
+
+          data = service.set_target_https_proxy_url_map(
+            identity, url_map
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def set_ssl_certificates(ssl_certificates, async = true)
+          requires :identity
+
+          data = service.set_target_https_proxy_ssl_certificates(
+            identity, ssl_certificates
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           reload
         end
 
         def ready?
-          service.get_target_https_proxy(name)
+          requires :identity
+
+          service.get_target_https_proxy(identity)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
         def reload
-          requires :name
+          requires :identity
 
           return unless data = begin
-            collection.get(name)
+            collection.get(identity)
           rescue Excon::Errors::SocketError
             nil
           end

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

@@ -4,48 +4,46 @@ module Fog
       class TargetInstance < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
-        attribute :description, :aliases => "description"
-        attribute :zone, :aliases => "zone"
-        attribute :instance, :aliases => "instance"
+        attribute :description
+        attribute :id
+        attribute :instance
+        attribute :kind
         attribute :nat_policy, :aliases => "natPolicy"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :zone
 
         def save
-          requires :name, :zone
+          requires :identity, :zone
 
           options = {
-            "description" => description,
-            "zone" => zone,
-            "natPolicy" => nat_policy,
-            "instance" => instance
+            :description => description,
+            :zone => zone,
+            :nat_policy => nat_policy,
+            :instance => instance
           }
 
-          data = service.insert_target_instance(name, zone, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          data = service.insert_target_instance(identity, zone, options)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
           operation.wait_for { !pending? }
           reload
         end
 
         def destroy(async = true)
           requires :name, :zone
-          operation = service.delete_target_instance(name, zone)
-          unless async
-            # wait until "DONE" to ensure the operation doesn't fail, raises
-            # exception on error
-            Fog.wait_for do
-              operation.body["status"] == "DONE"
-            end
-          end
+          data = service.delete_target_instance(name, zone)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def ready?
           service.get_target_instance(name, zone)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -62,7 +60,7 @@ module Fog
           end
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

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

@@ -4,32 +4,40 @@ module Fog
       class TargetInstances < Fog::Collection
         model Fog::Compute::Google::TargetInstance
 
-        def all(filters = {})
-          if filters["zone"]
-            data = service.list_target_instances(filters["zone"]).body["items"] || []
+        def all(zone: nil, filter: nil, max_results: nil, order_by: nil,
+                page_token: nil)
+          opts = {
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          }
+
+          if zone
+            data = service.list_target_instances(zone, opts).to_h[:items] || []
           else
             data = []
-            service.list_aggregated_target_instances.body["items"].each_value do |zone|
-              data.concat(zone["targetInstances"]) if zone["targetInstances"]
+            service.list_aggregated_target_instances(opts).items.each_value do |scoped_list|
+              unless scoped_list.nil? || scoped_list.target_instances.nil?
+                data += scoped_list.target_instances.map(&:to_h)
+              end
             end
           end
           load(data)
         end
 
-        def get(identity, zone = nil)
+        def get(target_instance, zone = nil)
           response = nil
           if zone
-            response = service.get_target_instance(identity, zone).body
+            response = service.get_target_instance(target_instance, zone).to_h
           else
-            target_instances = service.list_aggregated_target_instances(:filter => "name eq .*#{identity}").body["items"]
-            target_instance = target_instances.each_value.select { |zone| zone.key?("targetInstances") }
-
-            # It can only be 1 target_instance with the same name across all regions
-            response = target_instance.first["targetInstances"].first unless target_instance.empty?
+            response = all(:filter => "name eq #{target_instance}").first
+            response = response.attributes unless response.nil?
           end
           return nil if response.nil?
           new(response)
-        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/target_pool.rb

@@ -4,91 +4,134 @@ module Fog
       class TargetPool < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
+        attribute :backup_pool, :aliases => "backupPool"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
-        attribute :description, :aliases => "description"
-        attribute :region, :aliases => "region"
+        attribute :description
+        attribute :failover_ratio, :aliases => "failoverRatio"
         attribute :health_checks, :aliases => "healthChecks"
-        attribute :instances, :aliases => "instances"
+        attribute :id
+        attribute :instances
+        attribute :kind
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
         attribute :session_affinity, :aliases => "sessionAffinity"
-        attribute :failover_ratio, :aliases => "failoverRatio"
-        attribute :backup_pool, :aliases => "backupPool"
 
         def save
           requires :name, :region
 
-          options = {
-            "description" => description,
-            "region" => region,
-            "healthChecks" => health_checks,
-            "instances" => instances,
-            "sessionAffinity" => session_affinity,
-            "failoverRatio" => failover_ratio,
-            "backupPool" => backup_pool
-          }
-
-          data = service.insert_target_pool(name, region, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], nil, data["region"])
+          data = service.insert_target_pool(
+            name, region, attributes.reject { |_k, v| v.nil? }
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
           operation.wait_for { !pending? }
           reload
         end
 
         def destroy(async = true)
-          requires :name, :region
-          operation = service.delete_target_pool(name, region)
-          unless async
-            # wait until "DONE" to ensure the operation doesn't fail, raises
-            # exception on error
-            Fog.wait_for do
-              operation = service.get_region_operation(region, operation.body["name"])
-              operation.body["status"] == "DONE"
-            end
-          end
+          requires :identity, :region
+          data = service.delete_target_pool(identity, region)
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
           operation
         end
 
-        def add_instance(instance)
+        def add_instance(instance, async = true)
+          requires :identity
           instance = instance.self_link unless instance.class == String
-          service.add_target_pool_instances(self, [instance])
+          data = service.add_target_pool_instances(identity, region, [instance])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+
           reload
         end
 
-        def remove_instance(instance)
+        def remove_instance(instance, async = true)
+          requires :identity
+
           instance = instance.self_link unless instance.class == String
-          service.remove_target_pool_instances(self, [instance])
+          data = service.remove_target_pool_instances(identity, region, [instance])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+
+          operation.wait_for { ready? } unless async
+
           reload
         end
 
-        def add_health_check(health_check)
+        def add_health_check(health_check, async = true)
+          requires :identity, :region
+
           health_check = health_check.self_link unless health_check.class == String
-          service.add_target_pool_health_checks(self, [health_check])
+          data = service.add_target_pool_health_checks(identity, region, [health_check])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+
           reload
         end
 
-        def remove_health_check(health_check)
+        def remove_health_check(health_check, async = true)
+          requires :identity, :region
+
           health_check = health_check.self_link unless health_check.class == String
-          service.remove_target_pool_health_checks(self, [health_check])
+          data = service.remove_target_pool_health_checks(identity, region, [health_check])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
           reload
         end
 
+        ##
+        # Get most recent health checks for each IP for instances.
+        #
+        # @param [String] instance_name a specific instance to look up. Default
+        #   behavior returns health checks for all instances associated with
+        #   this check.
+        # @returns [Hash<String, Array<Hash>>] a map of instance URL to health checks
         def get_health(instance_name = nil)
+          requires :identity, :region
+
           if instance_name
             instance = service.servers.get(instance_name)
-            health_results = [service.get_target_pool_health(self, instance.self_link)]
+            data = service.get_target_pool_health(identity, region, instance.self_link)
+                          .to_h[:health_status] || []
+            results = [instance.self_link, data]
           else
-            health_results = instances.map do |instance_selflink|
-              service.get_target_pool_health(self, instance_selflink)
+            results = instances.map do |self_link|
+              data = service.get_target_pool_health(identity, region, self_link)
+                            .to_h[:health_status] || []
+              [self_link, data]
             end
           end
-          Hash[health_results]
+          Hash[results]
+        end
+
+        def set_backup(backup = nil)
+          requires :identity, :region
+
+          backup ||= backup_pool
+
+          service.set_target_pool_backup(
+            identity, region, backup,
+            :failover_ratio => failover_ratio
+          )
+          reload
         end
 
         def ready?
           service.get_target_pool(name, region)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -110,7 +153,7 @@ module Fog
           self
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

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

@@ -4,14 +4,22 @@ module Fog
       class TargetPools < Fog::Collection
         model Fog::Compute::Google::TargetPool
 
-        def all(filters = {})
-          if filters["region"].nil?
+        def all(region: nil, filter: nil, max_results: nil, order_by: nil, page_token: nil)
+          opts = {
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          }
+          if region.nil?
             data = []
-            service.list_regions.body["items"].each do |region|
-              data += service.list_target_pools(region["name"]).body["items"] || []
+            service.list_aggregated_target_pools(opts).items.each_value do |lst|
+              unless lst.nil? || lst.target_pools.nil?
+                data += lst.to_h[:target_pools]
+              end
             end
           else
-            data = service.list_target_pools(filters["region"]).body["items"] || []
+            data = service.list_target_pools(region, opts).to_h[:items]
           end
           load(data)
         end
@@ -19,18 +27,18 @@ module Fog
         def get(identity, region = nil)
           response = nil
           if region.nil?
-            service.regions.all.each do |region|
-              begin
-                response = service.get_target_pool(identity, region.name)
-                break if response.status == 200
-              rescue Fog::Errors::Error
-              end
+            data = all(:filter => "name eq #{identity}").first
+            unless data.nil?
+              response = data.attributes
             end
           else
-            response = service.get_target_pool(identity, region)
+            response = service.get_target_pool(identity, region).to_h
           end
           return nil if response.nil?
-          new(response.body)
+          new(response)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code = 404
+          nil
         end
       end
     end