gitlab-fog-google 1.13.0

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

@@ -0,0 +1,90 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceGroup < Fog::Model
+        identity :name
+
+        attribute :id
+        attribute :kind
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
+        attribute :fingerprint
+        attribute :namedPorts
+        attribute :network
+        attribute :subnetwork
+        attribute :self_link, :aliases => "selfLink"
+        attribute :size
+        attribute :zone, :aliases => :zone_name
+
+        def save
+          requires :name, :zone
+
+          options = {
+            "network" => network_name,
+            "subnetwork" => subnetwork_name
+          }
+
+          service.insert_instance_group(name, zone, options)
+        end
+
+        def destroy(_async = true)
+          requires :name, :zone
+
+          service.delete_instance_group(name, zone_name)
+        end
+
+        def add_instance(instance_id)
+          add_instances [instance_id]
+        end
+
+        def add_instances(instances)
+          requires :identity, :zone
+
+          service.add_instance_group_instances(
+            identity, zone_name, format_instance_list(instances)
+          )
+        end
+
+        def remove_instances(instances)
+          requires :identity, :zone
+
+          service.remove_instance_group_instances(
+            identity, zone_name, format_instance_list(instances)
+          )
+        end
+
+        def list_instances
+          requires :identity, :zone
+
+          instance_list = []
+          data = service.list_instance_group_instances(identity, zone_name)
+          if data.items
+            data.items.each do |instance|
+              instance_list << service.servers.get(instance.instance.split("/")[-1], zone_name)
+            end
+          end
+          instance_list
+        end
+
+        def zone_name
+          zone.nil? ? nil : zone.split("/")[-1]
+        end
+
+        def network_name
+          network.nil? ? nil : network.split("/")[-1]
+        end
+
+        def subnetwork_name
+          subnetwork.nil? ? nil : subnetwork.split("/")[-1]
+        end
+
+        private
+
+        def format_instance_list(instance_list)
+          instance_list = Array(instance_list)
+          instance_list.map { |i| i.class == String ? i : i.self_link }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceGroupManager < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :self_link, :aliases => "selfLink"
+        attribute :description
+        attribute :zone
+        attribute :region
+        attribute :instance_group, :aliases => "instanceGroup"
+        attribute :instance_template, :aliases => "instanceTemplate"
+        attribute :target_pools, :aliases => "targetPools"
+        attribute :base_instance_name, :aliases => "baseInstanceName"
+        attribute :current_actions, :aliases => "currentActions"
+        attribute :target_size, :aliases => "targetSize"
+        attribute :named_ports, :aliases => "namedPorts"
+
+        def save
+          requires :name, :zone, :base_instance_name, :target_size, :instance_template
+
+          data = service.insert_instance_group_manager(name, zone.split("/")[-1], instance_template, base_instance_name,
+          target_size, target_pools, named_ports, description)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.name, zone.split("/")[-1])
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :name, :zone
+          operation = service.delete_instance_group_manager(name, zone.split("/")[-1])
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        def set_instance_template(instance_template)
+          service.set_instance_template self, instance_template
+        end
+
+        def recreate_instances(instances)
+          service.recreate_instances self, instances
+        end
+
+        def abandon_instances(instances)
+          service.abandon_instances self, instances
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceGroupManagers < Fog::Collection
+        model Fog::Compute::Google::InstanceGroupManager
+
+        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_instance_group_managers(zone, opts).items || []
+          else
+            data = []
+            service.list_aggregated_instance_group_managers(opts).items.each_value do |group|
+              data.concat(group.instance_group_managers) if group.instance_group_managers
+            end
+          end
+
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            instance_group_manager = service.get_instance_group_manager(identity, zone).to_h
+            return new(instance_group_manager)
+          elsif identity
+            response = all(:filter => "name eq .*#{identity}",
+                           :max_results => 1)
+            instance_group_manager = response.first unless response.empty?
+            return instance_group_manager
+          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/instance_groups.rb

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceGroups < Fog::Collection
+        model Fog::Compute::Google::InstanceGroup
+
+        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_instance_groups(zone).items || []
+          else
+            data = []
+            service.list_aggregated_instance_groups(opts).items.each_value do |group|
+              data.concat(group.instance_groups) if group && group.instance_groups
+            end
+          end
+
+          load(data.map(&:to_h))
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            instance_group = service.get_instance_group(identity, zone).to_h
+            new(instance_group)
+          elsif identity
+            response = all(:filter => "name eq #{identity}",
+                           :max_results => 1)
+            instance_group = response.first unless response.empty?
+            return instance_group
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+
+          nil
+        end
+
+        # TODO(2.0): To be deprecated
+        def add_instance(params)
+          Fog::Logger.deprecation(
+            "#{self.class}.#{__method__} is deprecated, use Fog::Compute::Google::InstanceGroup.#{__method__} instead [light_black](#{caller(0..0)})[/]"
+          )
+          params[:instance] = [params[:instance]] unless params[:instance] == Array
+          service.add_instance_group_instances(params[:group], params[:zone], params[:instance])
+        end
+
+        # TODO(2.0): To be deprecated
+        def remove_instance(params)
+          Fog::Logger.deprecation(
+            "#{self.class}.#{__method__} is deprecated, use Fog::Compute::Google::InstanceGroup.#{__method__} instead [light_black](#{caller(0..0)})[/]"
+          )
+          params[:instance] = [params[:instance]] unless params[:instance] == Array
+          service.remove_instance_group_instances(params[:group], params[:zone], params[:instance])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceTemplate < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :self_link, :aliases => "selfLink"
+        attribute :description
+        # Properties is a hash describing the templates
+        # A minimal example is
+        # :properties => {
+        #   :machine_type => TEST_MACHINE_TYPE,
+        #   :disks => [{
+        #     :boot => true,
+        #     :initialize_params => {
+        #       :source_image => "projects/ubuntu-os-cloud/global/images/ubuntu-1804-bionic-v20180522"}
+        #     }],
+        #     :network_interfaces => [{
+        #       :network => "global/networks/default"
+        #     }]
+        #   }
+        # }
+        # @see https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert
+        attribute :properties
+
+        def save
+          requires :name
+          requires :properties
+
+          data = service.insert_instance_template(name, properties, description)
+          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_instance_template(name)
+          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/instance_templates.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class InstanceTemplates < Fog::Collection
+        model Fog::Compute::Google::InstanceTemplate
+
+        def all
+          data = service.list_instance_templates.items || []
+          load(data.map(&:to_h))
+        end
+
+        def get(identity)
+          if identity
+            instance_template = service.get_instance_template(identity).to_h
+            return new(instance_template)
+          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/machine_type.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class MachineType < Fog::Model
+        identity :name
+
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :deprecated
+        attribute :description
+        attribute :guest_cpus, :aliases => "guestCpus"
+        attribute :id
+        attribute :is_shared_cpu, :aliases => "isSharedCpu"
+        attribute :kind
+        attribute :maximum_persistent_disks, :aliases => "maximumPersistentDisks"
+        attribute :maximum_persistent_disks_size_gb, :aliases => "maximumPersistentDisksSizeGb"
+        attribute :memory_mb, :aliases => "memoryMb"
+        attribute :scratch_disks, :aliases => "scratchDisks"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :zone
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class Google
+      class MachineTypes < Fog::Collection
+        model Fog::Compute::Google::MachineType
+
+        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_machine_types(zone, opts).items
+          else
+            data = []
+            service.list_aggregated_machine_types(opts).items.each_value do |scoped_list|
+              data.concat(scoped_list.machine_types) if scoped_list && scoped_list.machine_types
+            end
+          end
+          load(data.map(&:to_h) || [])
+        end
+
+        def get(identity, zone = nil)
+          if zone
+            machine_type = service.get_machine_type(identity, zone).to_h
+            return new(machine_type)
+          elsif identity
+            # This isn't very functional since it just shows the first available
+            # machine type globally, but needed due to overall compatibility
+            # See: https://github.com/fog/fog-google/issues/352
+            response = all(:filter => "name eq #{identity}",
+                           :max_results => 1)
+            machine_type = response.first unless response.empty?
+            return machine_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/network.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Network resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/networks
+      class Network < Fog::Model
+        identity :name
+
+        attribute :auto_create_subnetworks, aliases => "autoCreateSubnetworks"
+        attribute :creation_timestamp, aliases => "creationTimestamp"
+        attribute :description
+        # TODO: Naming issue in the client lib, rename after this is resolved:
+        # https://github.com/google/google-api-ruby-client/issues/666
+        attribute :gateway_i_pv4, aliases => %w(gateway_ipv4 gatewayIPv4)
+        attribute :i_pv4_range, aliases => %w(ipv4_range IPv4Range)
+        attribute :id
+        attribute :kind
+        attribute :peerings
+        attribute :routing_config, aliases => "routingConfig"
+        attribute :self_link, aliases => "selfLink"
+        attribute :subnetworks
+
+        # TODO: Naming issue in the client lib, rename after this is resolved:
+        # https://github.com/google/google-api-ruby-client/issues/666
+        alias_method :ipv4_range, :i_pv4_range
+
+        def save
+          requires :identity, :ipv4_range
+
+          data = service.insert_network(identity, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          # Since network has no "state" we can query, we have to wait for the operation to finish
+          # TODO: change back to async when there's a proper state API
+          operation.wait_for { ready? }
+          reload
+        end
+
+        def destroy(async = true)
+          requires :identity
+
+          data = service.delete_network(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
+          operation
+        end
+
+        # Returns a ready API structure for insert_instance, used in insert_server request.
+        def get_as_interface_config(access_config = nil)
+          network_interface = { :network => self_link }
+          network_interface[:access_configs] = [access_config] if access_config
+          network_interface
+        end
+      end
+    end
+  end
+end