fog-google 0.6.0 → 1.0.0

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

@@ -4,60 +4,58 @@ module Fog
       class GlobalForwardingRule < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
+        attribute :ip_address, :aliases => "IPAddress"
+        attribute :ip_protocol, :aliases => "IPProtocol"
+        attribute :backend_service, :aliases => "backendService"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
-        attribute :description, :aliases => "description"
-        attribute :region, :aliases => "region" # should always be 'global'
-        attribute :ip_address, :aliases => "IPAddress" # string
-        attribute :ip_protocol, :aliases => "IPProtocol" # string
-        attribute :port_range, :aliases => "portRange" # string
-        attribute :target, :aliases => "target" # string, URL of global target http proxy
+        attribute :description
+        attribute :id
+        attribute :ip_version, :aliases => "ipVersion"
+        attribute :kind
+        attribute :load_balancing_scheme, :aliases => "loadBalancingScheme"
+        attribute :network
+        attribute :port_range, :aliases => "portRange"
+        attribute :ports
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+        attribute :subnetwork
+        attribute :target
 
         def save
-          requires :name
+          requires :identity
 
-          options = {
-            "description" => description,
-            "region" => "global",
-            "IPAddress" => ip_address,
-            "IPProtocol" => ip_protocol || "TCP",
-            "portRange" => port_range || 80,
-            "target" => target
-          }
-
-          data = service.insert_global_forwarding_rule(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], nil, data["region"])
+          data = service.insert_global_forwarding_rule(identity, attributes)
+          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
-
-          operation = service.delete_global_forwarding_rule(name, "global")
-          unless async
-            # wait until "RUNNING" or "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_global_forwarding_rule(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def set_target(new_target)
+          requires :identity
+
           new_target = new_target.self_link unless new_target.class == String
           self.target = new_target
-          service.set_global_forwarding_rule_target(self, new_target)
+          service.set_global_forwarding_rule_target(
+            identity, :target => new_target
+          )
           reload
         end
 
         def ready?
-          service.get_global_forwarding_rule(name, "global")
+          service.get_global_forwarding_rule(name)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -65,7 +63,7 @@ module Fog
           requires :name
 
           return unless data = begin
-            collection.get(name, "global")
+            collection.get(name)
           rescue Excon::Errors::SocketError
             nil
           end
@@ -74,8 +72,6 @@ module Fog
           merge_attributes(new_attributes)
           self
         end
-
-        RUNNING_STATE = "READY"
       end
     end
   end

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

@@ -4,16 +4,17 @@ module Fog
       class GlobalForwardingRules < Fog::Collection
         model Fog::Compute::Google::GlobalForwardingRule
 
-        def all
-          data = service.list_global_forwarding_rules.body["items"] || []
+        def all(opts = {})
+          data = service.list_global_forwarding_rules(opts).to_h[:items] || []
           load(data)
         end
 
-        def get(identity, region = "global")
-          if global_forwarding_rule = service.get_global_forwarding_rule(identity, region).body
-            new(global_forwarding_rule)
+        def get(identity)
+          if rule = service.get_global_forwarding_rule(identity).to_h
+            new(rule)
           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/http_health_check.rb

@@ -4,58 +4,82 @@ module Fog
       class HttpHealthCheck < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
+        attribute :check_interval_sec, :aliases => "checkIntervalSec"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
-        attribute :description, :aliases => "description"
-        attribute :host, :aliases => "host"
+        attribute :description
+        attribute :healthy_threshold, :aliases => "healthyThreshold"
+        attribute :host
+        attribute :id
+        attribute :kind
+        attribute :port
         attribute :request_path, :aliases => "requestPath"
-        attribute :port, :aliases => "port"
-        attribute :check_interval_sec, :aliases => "checkIntervalSec"
+        attribute :self_link, :aliases => "selfLink"
         attribute :timeout_sec, :aliases => "timeoutSec"
         attribute :unhealthy_threshold, :aliases => "unhealthyThreshold"
-        attribute :healthy_threshold, :aliases => "healthyThreshold"
+
+        MODIFIABLE_FIELDS = %i(
+          name
+          check_interval_sec
+          creation_timestamp
+          description
+          healthy_threshold
+          host
+          port
+          request_path
+          timeout_sec
+          unhealthy_threshold
+        ).freeze
 
         def save
+          opts = {
+            :name => name,
+            :check_interval_sec => check_interval_sec,
+            :creation_timestamp => creation_timestamp,
+            :description => description,
+            :healthy_threshold => healthy_threshold,
+            :host => host,
+            :port => port,
+            :request_path => request_path,
+            :timeout_sec => timeout_sec,
+            :unhealthy_threshold => unhealthy_threshold
+          }
+
+          id.nil? ? create(opts) : update(opts)
+        end
+
+        def create(opts)
           requires :name
 
-          options = {
-            "description" => description,
-            "host" => host,
-            "requestPath" => request_path || "/",
-            "port" => port || 80,
-            "checkIntervalSec" => check_interval_sec || 5,
-            "timeoutSec" => timeout_sec || 5,
-            "unhealthyThreshold" => unhealthy_threshold || 2,
-            "healthyThreshold" => healthy_threshold || 2
-          }
+          data = service.insert_http_health_check(name, opts)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { !pending? }
+          reload
+        end
 
-          data = service.insert_http_health_check(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], data["zone"])
+        def update(opts)
+          requires :name
+          data = service.update_http_health_check(name, opts)
+          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
-          operation = service.delete_http_health_check(name)
-
-          unless async
-            # wait until "DONE" to ensure the operation doesn't fail, raises
-            # exception on error
-            Fog.wait_for do
-              operation = service.get_global_operation(operation.body["name"])
-              operation.body["status"] == "DONE"
-            end
-          end
+          data = service.delete_http_health_check(name)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def ready?
           service.get_http_health_check(name)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
@@ -73,7 +97,7 @@ module Fog
           self
         end
 
-        RUNNING_STATE = "READY"
+        RUNNING_STATE = "READY".freeze
       end
     end
   end

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

@@ -5,16 +5,16 @@ module Fog
         model Fog::Compute::Google::HttpHealthCheck
 
         def all(_filters = {})
-          data = service.list_http_health_checks.body["items"] || []
+          data = service.list_http_health_checks.to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          response = nil
           response = service.get_http_health_check(identity)
           return nil if response.nil?
-          new(response.body)
-        rescue Fog::Errors::NotFound
+          new(response.to_h)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -4,25 +4,17 @@ module Fog
       class Image < Fog::Model
         identity :name
 
-        attribute :id
-        attribute :kind
         attribute :archive_size_bytes, :aliases => "archiveSizeBytes"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :deprecated
         attribute :description
         attribute :disk_size_gb, :aliases => "diskSizeGb"
         attribute :family
+        attribute :guest_os_features, :aliases => "guestOsFeatures"
+        attribute :id
+        attribute :image_encryption_key, :aliases => "imageEncryptionKey"
+        attribute :kind
         attribute :licenses
-        attribute :self_link, :aliases => "selfLink"
-        attribute :source_type, :aliases => "sourceType"
-        attribute :status
-
-        # This attribute is not available in the representation of an
-        # 'image' returned by the GCE servser (see GCE API). However,
-        # images are a global resource and a user can query for images
-        # across projects. Therefore we try to remember which project
-        # the image belongs to by tracking it in this attribute.
-        attribute :project
 
         # A RawDisk, e.g. -
         # {
@@ -32,16 +24,24 @@ module Fog
         # }
         attribute :raw_disk, :aliases => "rawDisk"
 
-        def preferred_kernel=(_args)
-          Fog::Logger.deprecation("preferred_kernel= is no longer used [light_black](#{caller.first})[/]")
-        end
+        attribute :self_link, :aliases => "selfLink"
+        attribute :source_disk, :aliases => "sourceDisk"
+        attribute :source_disk_encryption_key, :aliases => "sourceDiskEncryptionKey"
+        attribute :source_disk_id, :aliases => "sourceDiskId"
+        attribute :source_image, :aliases => "sourceImage"
+        attribute :source_image_encryption_key, :aliases => "sourceImageEncryptionKey"
+        attribute :source_image_id, :aliases => "sourceImageId"
+        attribute :source_type, :aliases => "sourceType"
+        attribute :status
 
-        def preferred_kernel
-          Fog::Logger.deprecation("preferred_kernel is no longer used [light_black](#{caller.first})[/]")
-          nil
-        end
+        # This attribute is not available in the representation of an
+        # 'image' returned by the GCE server (see GCE API). However,
+        # images are a global resource and a user can query for images
+        # across projects. Therefore we try to remember which project
+        # the image belongs to by tracking it in this attribute.
+        attribute :project
 
-        READY_STATE = "READY"
+        READY_STATE = "READY".freeze
 
         def ready?
           status == READY_STATE
@@ -49,32 +49,25 @@ module Fog
 
         def destroy(async = true)
           data = service.delete_image(name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { ready? } unless async
           operation
         end
 
         def reload
           requires :name
-
-          self.project = service.project
-          data = service.get_image(name, project).body
-
-          merge_attributes(data)
+          data = service.get_image(name, project)
+          merge_attributes(data.to_h)
           self
         end
 
         def save
           requires :name
-          requires :raw_disk
-
-          options = {
-            "rawDisk"         => raw_disk,
-            "description"     => description
-          }
 
-          data = service.insert_image(name, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          data = service.insert_image(name, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end

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

@@ -8,73 +8,73 @@ module Fog
         # charged a license fee beyond the base Google Compute Engine VM
         # charges. See https://cloud.google.com/compute/docs/operating-systems/
         # for more info.
-        GLOBAL_PROJECTS = [
-          "centos-cloud",
-          "coreos-cloud",
-          "debian-cloud",
-          "google-containers",
-          "opensuse-cloud",
-          "rhel-cloud",
-          "suse-cloud",
-          "ubuntu-os-cloud",
-          "windows-cloud"
-        ]
+        GLOBAL_PROJECTS = %w(
+          centos-cloud
+          cos-cloud
+          coreos-cloud
+          debian-cloud
+          rhel-cloud
+          suse-cloud
+          suse-sap-cloud
+          ubuntu-os-cloud
+          windows-cloud
+          windows-sql-cloud
+          google-containers
+          opensuse-cloud
+        ).freeze
 
         def all
-          data = []
-
-          all_projects.each do |project|
+          data = all_projects.map do |project|
             begin
-              images = service.list_images(project).body["items"] || []
-
+              images = service.list_images(project).items || []
               # Keep track of the project in which we found the image(s)
-              images.each { |img| img[:project] = project }
-              data += images
-            rescue Fog::Errors::NotFound
+              images.map { |img| img.to_h.merge(:project => project) }
+            rescue ::Google::Apis::ClientError => e
+              raise e unless e.status_code == 404
               # Not everyone has access to every Global Project. Requests
               # return 404 if you don't have access.
               next
             end
           end
+          data = data.flatten
 
           load(data)
         end
 
         # Only return the non-deprecated list of images
         def current
-          data = []
-          all_images = all
-          all_images.each { |img| data.push(img) unless img.deprecated }
-          data
+          all.reject(&:deprecated)
         end
 
-        def get(identity)
+        def get(identity, project = nil)
+          project.nil? ? projects = all_projects : projects = [project]
           data = nil
-
-          all_projects.each do |project|
+          projects.each do |proj|
             begin
-              data = service.get_image(identity, project).body
-              data[:project] = project
-            rescue Fog::Errors::NotFound
-              next
+              data = service.get_image(identity, proj).to_h
+              data[:project] = proj
+            rescue ::Google::Apis::ClientError => e
+              next if e.status_code == 404
+              break
             else
               break
             end
           end
+
           return nil if data.nil?
           new(data)
         end
 
-        def get_from_family(family)
+        def get_from_family(family, project = nil)
+          project.nil? ? projects = all_projects : projects = [project]
           data = nil
-          
-          all_projects.each do |project|
+
+          projects.each do |proj|
             begin
-              data = service.get_image_from_family(family, project).body
-              data[:project] = project
-            rescue Fog::Errors::NotFound
-              next
-            else
+              data = service.get_image_from_family(family, proj).to_h
+              data[:project] = proj
+            rescue ::Google::Apis::ClientError => e
+              next if e.status_code == 404
               break
             end
           end