gitlab-fog-google 1.13.0

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class Google
+      class GlobalAddresses < Fog::Collection
+        model Fog::Compute::Google::GlobalAddress
+
+        def all(options = {})
+          data = service.list_global_addresses(options).to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            address = service.get_global_address(identity).to_h
+            return new(address)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+
+        def get_by_ip_address(ip_address)
+          data = service.list_global_addresses(:filter => "address eq #{ip_address}")
+          if data.nil? || data.items.nil?
+            nil
+          else
+            new(data.items.first.to_h)
+          end
+        end
+
+        def get_by_name(ip_name)
+          data = service.list_global_addresses(:filter => "name eq #{ip_name}")
+          if data.nil? || data.items.nil?
+            nil
+          else
+            new(data.items.first.to_h)
+          end
+        end
+
+        def get_by_ip_address_or_name(ip_address_or_name)
+          get_by_ip_address(ip_address_or_name) || get_by_name(ip_address_or_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Fog
+  module Compute
+    class Google
+      class GlobalForwardingRule < Fog::Model
+        identity :name
+
+        attribute :ip_address, :aliases => "IPAddress"
+        attribute :ip_protocol, :aliases => "IPProtocol"
+        attribute :backend_service, :aliases => "backendService"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        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 :identity
+
+          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 { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          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(
+            identity, :target => new_target
+          )
+          reload
+        end
+
+        def ready?
+          service.get_global_forwarding_rule(name)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class GlobalForwardingRules < Fog::Collection
+        model Fog::Compute::Google::GlobalForwardingRule
+
+        def all(opts = {})
+          data = service.list_global_forwarding_rules(opts).to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            rule = service.get_global_forwarding_rule(identity).to_h
+            return new(rule)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Fog
+  module Compute
+    class Google
+      class HttpHealthCheck < Fog::Model
+        identity :name
+
+        attribute :check_interval_sec, :aliases => "checkIntervalSec"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :healthy_threshold, :aliases => "healthyThreshold"
+        attribute :host
+        attribute :id
+        attribute :kind
+        attribute :port
+        attribute :request_path, :aliases => "requestPath"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :timeout_sec, :aliases => "timeoutSec"
+        attribute :unhealthy_threshold, :aliases => "unhealthyThreshold"
+
+        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
+
+          data = service.insert_http_health_check(name, opts)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        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 { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name
+          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 ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        RUNNING_STATE = "READY".freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class HttpHealthChecks < Fog::Collection
+        model Fog::Compute::Google::HttpHealthCheck
+
+        def all(_filters = {})
+          data = service.list_http_health_checks.to_h[:items] || []
+          load(data)
+        end
+
+        def get(identity)
+          if identity
+            http_health_check = service.get_http_health_check(identity).to_h
+            return new(http_health_check)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Fog
+  module Compute
+    class Google
+      class Image < Fog::Model
+        identity :name
+
+        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
+
+        # A RawDisk, e.g. -
+        # {
+        #   :source         => url_to_gcs_file,
+        #   :container_type => 'TAR',
+        #   :sha1Checksum   => ,
+        # }
+        attribute :raw_disk, :aliases => "rawDisk"
+
+        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
+
+        # 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".freeze
+
+        def ready?
+          status == READY_STATE
+        end
+
+        def destroy(async = true)
+          data = service.delete_image(name)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def reload
+          requires :name
+          data = service.get_image(name, project)
+          merge_attributes(data.to_h)
+          self
+        end
+
+        def save
+          requires :name
+
+          data = service.insert_image(name, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def resource_url
+          "#{project}/global/images/#{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Fog
+  module Compute
+    class Google
+      class Images < Fog::Collection
+        model Fog::Compute::Google::Image
+
+        # NOTE: some of these operating systems are premium and users will be
+        # 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 = %w(
+          centos-cloud
+          cos-cloud
+          coreos-cloud
+          debian-cloud
+          rhel-cloud
+          rhel-sap-cloud
+          suse-cloud
+          suse-sap-cloud
+          ubuntu-os-cloud
+          windows-cloud
+          windows-sql-cloud
+          opensuse-cloud
+        ).freeze
+
+        def all
+          data = all_projects.map do |project|
+            begin
+              images = service.list_images(project).items || []
+              # Keep track of the project in which we found the image(s)
+              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
+          all.reject(&:deprecated)
+        end
+
+        def get(identity, project = nil)
+          if project
+            begin
+              image = service.get_image(identity, project).to_h
+              # TODO: Remove response modification - see #405
+              image[:project] = project
+              return new(image)
+            rescue ::Google::Apis::ClientError => e
+              raise e unless e.status_code == 404
+              nil
+            end
+          elsif identity
+            projects = all_projects
+            projects.each do |proj|
+              begin
+                response = service.get_image(identity, proj).to_h
+                # TODO: Remove response modification - see #405
+                response[:project] = proj
+                image = response
+                return new(image)
+              rescue ::Google::Apis::ClientError => e
+                next if e.status_code == 404
+                break
+              end
+            end
+            # If nothing is found - return nil
+            nil
+          end
+        end
+
+        def get_from_family(family, project = nil)
+          project.nil? ? projects = all_projects : projects = [project]
+          data = nil
+
+          projects.each do |proj|
+            begin
+              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
+          return nil if data.nil?
+          new(data)
+        end
+
+        private
+
+        def all_projects
+          # Search own project before global projects
+          project_list = [service.project] + GLOBAL_PROJECTS + service.extra_global_projects
+          unless service.exclude_projects.empty?
+            project_list.delete_if { |project| service.exclude_projects.include?(project) }
+          end
+          project_list
+        end
+      end
+    end
+  end
+end