gitlab-fog-google 1.13.0

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

@@ -0,0 +1,133 @@
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents an Address resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/addresses
+      class Address < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :address
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :region
+        attribute :self_link, :aliases => "selfLink"
+        attribute :status
+        attribute :users
+
+        IN_USE_STATE   = "IN_USE".freeze
+        RESERVED_STATE = "RESERVED".freeze
+        RESERVING_STATE = "RESERVING".freeze
+
+        def server
+          return nil if !in_use? || users.nil? || users.empty?
+
+          service.servers.get(users.first.split("/")[-1])
+        end
+
+        def server=(server)
+          requires :identity, :region
+          server ? associate(server) : disassociate
+        end
+
+        def save
+          requires :identity, :region
+
+          data = service.insert_address(identity, region, 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, :region
+
+          data = service.delete_address(identity, region.split("/")[-1])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, nil, data.region)
+
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def reload
+          requires :identity, :region
+
+          data = collection.get(identity, region.split("/")[-1])
+          merge_attributes(data.attributes)
+          self
+        end
+
+        def in_use?
+          status == IN_USE_STATE
+        end
+
+        def ready?
+          status != RESERVING_STATE
+        end
+
+        private
+
+        # Associates the ip address to a given server
+        #
+        # @param [String]  server - GCE instance name
+        # @param [String]  nic_name - NIC interface name, defaults to GCE
+        #                             standard primary nic - "nic0"
+        # @param [Boolean]  async - whether to run the operation asynchronously
+        #
+        # @return [Fog::Compute::Google::Operation]
+        def associate(server, nic_name = "nic0", async = false)
+          requires :address
+
+          data = service.add_server_access_config(
+            server.name, server.zone, nic_name, :nat_ip => address
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+        end
+
+        # Disassociates the ip address from a resource it's attached to
+        #
+        # @param [Boolean]  async - whether to run the operation asynchronously
+        #
+        # @return [Fog::Compute::Google::Operation]
+        def disassociate(async = false)
+          requires :address
+
+          return nil if !in_use? || users.nil? || users.empty?
+
+          server_name = users.first.split("/")[-1]
+
+          # An address can only be associated with one server at a time
+          server = service.servers.get(server_name)
+          server.network_interfaces.each do |nic|
+            # Skip if nic has no access_config
+            next if nic[:access_configs].nil? || nic[:access_configs].empty?
+
+            access_config = nic[:access_configs].first
+
+            # Skip access_config with different address
+            next if access_config[:nat_ip] != address
+
+            data = service.delete_server_access_config(
+              server.name, server.zone, nic[:name], access_config[:name]
+            )
+            operation = Fog::Compute::Google::Operations
+                        .new(:service => service)
+                        .get(data.name, data.zone)
+            operation.wait_for { ready? } unless async
+            return operation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class Google
+      class Addresses < Fog::Collection
+        model Fog::Compute::Google::Address
+
+        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
+            data = service.list_addresses(region, opts).items || []
+          else
+            data = []
+            service.list_aggregated_addresses(opts).items.each_value do |scoped_list|
+              data.concat(scoped_list.addresses) if scoped_list && scoped_list.addresses
+            end
+          end
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, region = nil)
+          if region
+            address = service.get_address(identity, region).to_h
+            return new(address)
+          elsif identity
+            response = all(:filter => "name eq #{identity}",
+                           :max_results => 1)
+            address = response.first unless response.empty?
+            return address
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+
+        def get_by_ip_address(ip_address)
+          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").items
+          address = addresses.each_value.select(&:addresses)
+
+          return nil if address.empty?
+          new(address.first.addresses.first.to_h)
+        end
+
+        def get_by_name(ip_name)
+          names = service.list_aggregated_addresses(:filter => "name eq .*#{ip_name}").items
+          name = names.each_value.select(&:addresses)
+
+          return nil if name.empty?
+          new(name.first.addresses.first.to_h)
+        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/backend_service.rb

@@ -0,0 +1,86 @@
+module Fog
+  module Compute
+    class Google
+      class BackendService < Fog::Model
+        identity :name
+
+        attribute :backends
+        attribute :creation_timestamp
+        attribute :description
+        attribute :fingerprint
+        attribute :health_checks, :aliases => "healthChecks"
+        attribute :id
+        attribute :kind
+        attribute :port
+        attribute :protocol
+        attribute :self_link, :aliases => "selfLink"
+        attribute :timeout_sec, :aliases => "timeoutSec"
+
+        def save
+          requires :name, :health_checks
+
+          options = {
+            :description => description,
+            :backends => backends,
+            :fingerprint => fingerprint,
+            :health_checks => health_checks,
+            :port => port,
+            :protocol => protocol,
+            :timeout_sec => timeout_sec
+          }
+
+          data = service.insert_backend_service(name, options)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name
+
+          data = service.delete_backend_service(name)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def get_health
+          service.get_backend_service_health(self)
+        end
+
+        def add_backend(backend)
+          # ensure backend is an array of hashes
+          backend = [backend] unless backend.class == Array
+          backend.map! { |resource| resource.class == String ? { "group" => resource } : resource }
+          service.add_backend_service_backends(self, backend)
+          reload
+        end
+
+        def ready?
+          service.get_backend_service(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/backend_services.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class BackendServices < Fog::Collection
+        model Fog::Compute::Google::BackendService
+
+        def all(_filters = {})
+          data = service.list_backend_services.items || []
+          load(data.map(&:to_h))
+        end
+
+        def get(identity)
+          if identity
+            backend_service = service.get_backend_service(identity).to_h
+            return new(backend_service)
+          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/disk.rb

@@ -0,0 +1,155 @@
+module Fog
+  module Compute
+    class Google
+      class Disk < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :zone, :aliases => :zone_name
+        attribute :status
+        attribute :description
+        attribute :size_gb, :aliases => "sizeGb"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :source_image, :aliases => "sourceImage"
+        attribute :source_image_id, :aliases => "sourceImageId"
+        attribute :source_snapshot, :aliases => "sourceSnapshot"
+        attribute :source_snapshot_id, :aliases => "sourceSnapshotId"
+        attribute :type
+        attribute :labels
+        attribute :label_fingerprint, :aliases => "labelFingerprint"
+        attribute :users
+
+        def default_description
+          if !source_image.nil?
+            "created from image: #{source_image}"
+          elsif !source_snapshot.nil?
+            "created from snapshot: #{source_snapshot}"
+          else
+            "created with fog"
+          end
+        end
+
+        def save
+          requires :name, :zone, :size_gb
+
+          options = {
+            :description => description || default_description,
+            :type => type,
+            :size_gb => size_gb,
+            :source_image => source_image,
+            :source_snapshot => source_snapshot,
+            :labels => labels
+          }.reject { |_, v| v.nil? }
+
+          if options[:source_image]
+            unless source_image.include?("projects/")
+              options[:source_image] = service.images.get(source_image).self_link
+            end
+          end
+
+          # Request needs backward compatibility so source image is specified in
+          # method arguments
+          data = service.insert_disk(name, zone, options[:source_image], options)
+          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, :zone
+
+          data = service.delete_disk(name, zone_name)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def zone_name
+          zone.nil? ? nil : zone.split("/")[-1]
+        end
+
+        # Returns an attached disk configuration hash.
+        #
+        # Compute API needs attached disks to be specified in a custom format.
+        # This provides a handy shortcut for generating a preformatted config.
+        #
+        # Example output:
+        # {:auto_delete=>false,
+        #  :boot=>true,
+        #  :mode=>"READ_WRITE",
+        #  :source=>"https://www.googleapis.com/compute/v1/projects/myproj/zones/us-central1-f/disks/mydisk",
+        #  :type=>"PERSISTENT"}
+        #
+        # See Instances.insert API docs for more info:
+        # https://cloud.google.com/compute/docs/reference/rest/v1/instances/insert
+        #
+        # @param [Hash]  opts  options to attach the disk with.
+        #   @option opts [Boolean]  :writable  The mode in which to attach this
+        #     disk. (defaults to READ_WRITE)
+        #   @option opts [Boolean]  :boot  Indicates whether this is a boot disk.
+        #     (defaults to false)
+        #   @option opts [String]  :device_name  Specifies a unique device name
+        #     of your choice that is reflected into the /dev/disk/by-id/google-*
+        #     tree of a Linux operating system running within the instance.
+        #   @option opts [Object]  :encryption_key  Encrypts or decrypts a disk
+        #     using a customer-supplied encryption key.
+        #   @option opts [Object]  :auto_delete  Specifies whether the disk will
+        #     be auto-deleted when the instance is deleted. (defaults to false)
+        #
+        # @return [Hash] Attached disk configuration hash
+        def attached_disk_obj(opts = {})
+          requires :self_link
+          collection.attached_disk_obj(self_link, opts)
+        end
+
+        # A legacy shorthand for attached_disk_obj
+        #
+        # @param [Object]  writable  The mode in which to attach this disk.
+        #   (defaults to READ_WRITE)
+        # @param [Object]  auto_delete  Specifies whether the disk will be
+        #   auto-deleted when the instance is deleted. (defaults to false)
+        # @return [Hash]
+        def get_as_boot_disk(writable = true, auto_delete = false)
+          attached_disk_obj(boot: true,
+                            writable: writable,
+                            auto_delete: auto_delete)
+        end
+
+        def ready?
+          status == RUNNING_STATE
+        end
+
+        def reload
+          requires :identity, :zone
+
+          return unless data = begin
+            collection.get(identity, zone_name)
+          rescue Google::Apis::TransmissionError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        def create_snapshot(snapshot_name, snapshot = {})
+          requires :name, :zone
+          raise ArgumentError, "Invalid snapshot name" unless snapshot_name
+
+          data = service.create_disk_snapshot(snapshot_name, name, zone_name, snapshot)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, data.zone)
+          operation.wait_for { ready? }
+          service.snapshots.get(snapshot_name)
+        end
+
+        RUNNING_STATE = "READY".freeze
+      end
+    end
+  end
+end