gitlab-fog-google 1.13.0

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

@@ -0,0 +1,27 @@
+module Fog
+  module Compute
+    class Google
+      class DiskType < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :default_disk_size_gb, :aliases => "defaultDiskSizeGb"
+        attribute :deprecated
+        attribute :description
+        attribute :self_link, :aliases => "selfLink"
+        attribute :valid_disk_size, :aliases => "validDiskSize"
+        attribute :zone
+
+        def reload
+          requires :identity, :zone
+
+          data = collection.get(identity, zone)
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Compute
+    class Google
+      class DiskTypes < Fog::Collection
+        model Fog::Compute::Google::DiskType
+
+        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_disk_types(zone, opts).items
+          else
+            data = []
+            service.list_aggregated_disk_types(opts).items.each_value do |scoped_lst|
+              data.concat(scoped_lst.disk_types) if scoped_lst && scoped_lst.disk_types
+            end
+          end
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            disk_type = service.get_disk_type(identity, zone).to_h
+            return new(disk_type)
+          else
+            response = all(:filter => "name eq .*#{identity}")
+            disk_type = response.first unless response.empty?
+            return disk_type
+          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/disks.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Compute
+    class Google
+      class Disks < Fog::Collection
+        model Fog::Compute::Google::Disk
+
+        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_disks(zone, opts).items || []
+          else
+            data = []
+            service.list_aggregated_disks(opts).items.each_value do |scoped_list|
+              data.concat(scoped_list.disks) if scoped_list.disks
+            end
+          end
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            disk = service.get_disk(identity, zone).to_h
+            return new(disk)
+          elsif identity
+            response = all(:filter => "name eq #{identity}",
+                           :max_results => 1)
+            disk = response.first unless response.empty?
+            return disk
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        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 [String]  source  self_link of an existing disk resource
+        # @param [Boolean]  writable  The mode in which to attach this disk.
+        #   (defaults to READ_WRITE)
+        # @param [Boolean]  boot  Indicates whether this is a boot disk.
+        #   (defaults to false)
+        # @param [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.
+        # @param [Object]  encryption_key  Encrypts or decrypts a disk using
+        #   a customer-supplied encryption key.
+        # @param [Object]  auto_delete  Specifies whether the disk will be
+        #   auto-deleted when the instance is deleted. (defaults to false)
+        # @return [Hash]
+        def attached_disk_obj(source,
+                              writable: true,
+                              boot: false,
+                              device_name: nil,
+                              encryption_key: nil,
+                              auto_delete: false)
+          {
+            :auto_delete => auto_delete,
+            :boot => boot,
+            :device_name => device_name,
+            :disk_encryption_key => encryption_key,
+            :mode => writable ? "READ_WRITE" : "READ_ONLY",
+            :source => source,
+            :type => "PERSISTENT"
+          }.reject { |_k, v| v.nil? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Firewall resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/firewalls
+      class Firewall < Fog::Model
+        identity :name
+
+        # Allowed ports in API format
+        #
+        # @example
+        # [
+        #   { :ip_protocol => "TCP",
+        #     :ports => ["201"] }
+        # ]
+        # @return [Array<Hash>]
+        attribute :allowed
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        # Denied ports in API format
+        #
+        # @example
+        # [
+        #   { :ip_protocol => "TCP",
+        #     :ports => ["201"] }
+        # ]
+        # @return [Array<Hash>]
+        attribute :denied
+        attribute :description
+        attribute :destination_ranges, :aliases => "destinationRanges"
+        attribute :direction
+        attribute :id
+        attribute :kind
+        attribute :network
+        attribute :priority
+        attribute :self_link, :aliases => "selfLink"
+        attribute :source_ranges, :aliases => "sourceRanges"
+        attribute :source_service_accounts, :aliases => "sourceServiceAccounts"
+        attribute :source_tags, :aliases => "sourceTags"
+        attribute :target_service_accounts, :aliases => "targetServiceAccounts"
+        attribute :target_tags, :aliases => "targetTags"
+
+        def save
+          requires :identity
+
+          unless self.allowed || self.denied
+            raise Fog::Errors::Error.new("Firewall needs denied or allowed ports specified")
+          end
+
+          id.nil? ? create : update
+        end
+
+        def create
+          data = service.insert_firewall(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def update
+          requires :identity, :allowed, :network
+
+          data = service.update_firewall(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def patch(diff = {})
+          requires :identity
+
+          data = service.patch_firewall(identity, diff)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity
+
+          data = service.delete_firewall(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Firewalls < Fog::Collection
+        model Fog::Compute::Google::Firewall
+
+        def all(opts = {})
+          data = service.list_firewalls(opts).to_h[:items]
+          load(data || [])
+        end
+
+        def get(identity)
+          if identity
+            firewall = service.get_firewall(identity).to_h
+            return new(firewall)
+          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/forwarding_rule.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Compute
+    class Google
+      class ForwardingRule < 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, :region
+
+          data = service.insert_forwarding_rule(identity, region, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def set_target(new_target)
+          requires :identity, :region
+
+          new_target = new_target.self_link unless new_target.class == String
+          self.target = new_target
+          service.set_forwarding_rule_target(
+            identity, region, :target => new_target
+          )
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity, :region
+          data = service.delete_forwarding_rule(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 ready?
+          requires :identity
+          service.get_forwarding_rule(identity, region)
+          true
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          false
+        end
+
+        def reload
+          requires :name, :region
+
+          return unless data = begin
+            collection.get(name, region)
+          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/forwarding_rules.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class Google
+      class ForwardingRules < Fog::Collection
+        model Fog::Compute::Google::ForwardingRule
+
+        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_forwarding_rules(region, opts).items || []
+          else
+            data = []
+            service.list_aggregated_forwarding_rules(opts).items
+                   .each_value do |scoped_list|
+              if scoped_list && scoped_list.forwarding_rules
+                data.concat(scoped_list.forwarding_rules)
+              end
+            end
+          end
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, region = nil)
+          if region
+            forwarding_rule = service.get_forwarding_rule(identity, region).to_h
+            return new(forwarding_rule)
+          elsif identity
+            response = all(
+              :filter => "name eq #{identity}", :max_results => 1
+            )
+            forwarding_rule = response.first unless response.empty?
+            return forwarding_rule
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents an Address resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/addresses
+      class GlobalAddress < Fog::Model
+        identity :name
+
+        attribute :address
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :id
+        attribute :ip_version, :aliases => "ipVersion"
+        attribute :kind
+        attribute :self_link, :aliases => "selfLink"
+        attribute :status
+        attribute :users
+
+        IN_USE_STATE   = "IN_USE".freeze
+        RESERVED_STATE = "RESERVED".freeze
+
+        def save
+          requires :identity
+
+          data = service.insert_global_address(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity
+
+          data = service.delete_global_address(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def reload
+          requires :identity
+
+          data = collection.get(identity)
+          merge_attributes(data.attributes)
+          self
+        end
+
+        def in_use?
+          status == IN_USE_STATE
+        end
+      end
+    end
+  end
+end