gitlab-fog-google 1.13.0

data/lib/fog/compute/google/requests/insert_instance_group_manager.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_instance_group_manager(_name, _zone, _instance_template, _base_instance_name,
+                                          _target_size, _target_pools, _named_ports, _description)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_instance_group_manager(name, zone, instance_template, base_instance_name,
+                                          target_size, target_pools, named_ports, description)
+          instance_group_manager = ::Google::Apis::ComputeV1::InstanceGroupManager.new(
+            :description => description,
+            :name => name,
+            :instance_template => instance_template.self_link,
+            :base_instance_name => base_instance_name,
+            :target_size => target_size,
+            :named_ports => named_ports || [],
+            :target_pools => target_pools || [],
+          )
+
+          @compute.insert_instance_group_manager(@project, zone, instance_group_manager)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_instance_template.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_instance_template(_name, _properties, _description)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        ##
+        # Create a new template.
+        #
+        # @param name [String]
+        #   Name to assign to the created template. Must be unique.
+        # @param descrption [String]
+        #   Optional description of the template
+        # @param properties [Hash]
+        #   Template attributes. You can use any of the options documented at
+        #   https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert
+        # @see https://cloud.google.com/compute/docs/reference/rest/v1/instanceTemplates/insert
+        # @return [::Google::Apis::ComputeV1::Operation]
+        #   response object that represents the insertion operation.
+        def insert_instance_template(name, properties, description)
+          instance_template = ::Google::Apis::ComputeV1::InstanceTemplate.new(
+            :description => description,
+            :name => name,
+            :properties => properties,
+          )
+
+          @compute.insert_instance_template(@project, instance_template)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_network.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_network(_network_name, _opts = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        INSERTABLE_NETWORK_FIELDS = %i{
+          auto_create_subnetworks
+          description
+          gateway_i_pv4
+          i_pv4_range
+          name
+          routing_config
+        }.freeze
+
+        def insert_network(network_name, opts = {})
+          opts = opts.select { |k, _| INSERTABLE_NETWORK_FIELDS.include? k }
+                     .merge(:name => network_name)
+
+          @compute.insert_network(
+            @project,
+            ::Google::Apis::ComputeV1::Network.new(opts)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_route.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_route(_route_name, _network, _dest_range, _priority, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Creates a Route resource.
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/routes/insert
+        def insert_route(route_name, network, dest_range, priority, options = {})
+          route = ::Google::Apis::ComputeV1::Route.new(
+            :name => route_name,
+            :network => network,
+            :dest_range => dest_range,
+            :priority => priority,
+            :tags => options[:tags] || [],
+            :next_hop_instance => options[:next_hop_instance],
+            :next_hop_gateway => options[:next_hop_gateway],
+            :next_hop_ip => options[:next_hop_ip],
+            :next_hop_vpn_tunnel => options[:next_hop_vpn_tunnel],
+            :description => options[:description]
+          )
+
+          @compute.insert_route(@project, route)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_server.rb

@@ -0,0 +1,122 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_server(_instance_name, _zone, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def default_network_interface
+          { :network => "global/networks/#{GOOGLE_COMPUTE_DEFAULT_NETWORK}" }
+        end
+
+        def process_disks(disks)
+          unless disks && !disks.empty?
+            raise ArgumentError.new("at least one value for disks is required")
+          end
+
+          disk_lst = disks.map do |d|
+            d = d.attached_disk_obj if d.is_a? Disk
+            ::Google::Apis::ComputeV1::AttachedDisk.new(d)
+          end
+          disk_lst.first.boot = true
+          disk_lst
+        end
+
+        def process_network_interfaces(network_interfaces)
+          unless network_interfaces && !network_interfaces.empty?
+            network_interfaces = [default_network_interface]
+          end
+          network_interfaces.map do |network|
+            ::Google::Apis::ComputeV1::NetworkInterface.new(network)
+          end
+        end
+
+        ##
+        # Create a new instance (virtual machine).
+        #
+        # This method allows you to use low-level request options and thus
+        # expects instance options similar to API requests. If you don't need to
+        # modify low-level request options, consider using the
+        # Fog::Compute::Google::Servers collection object instead.
+        #
+        # @example minimal server creation
+        #     my_operation = client.insert_server(
+        #       "my-server",
+        #       "us-central1-a",
+        #       :machine_type => "f1-micro",
+        #       :disks => [
+        #         {
+        #           :initialize_params => {
+        #             :source_image => "projects/debian-cloud/global/images/family/debian-9"
+        #           }
+        #         }
+        #       ]
+        #     )
+        #
+        # @param instance_name [String]
+        #   Name to assign to the created server. Must be unique within the specified zone.
+        # @param zone [String]
+        #   Name or URL of zone containing the created server.
+        # @param options [Hash]
+        #   Server attributes. You can use any of the options documented at
+        #   https://cloud.google.com/compute/docs/reference/latest/instances/insert.
+        # @see https://cloud.google.com/compute/docs/reference/latest/instances/insert
+        # @return [::Google::Apis::ComputeV1::Operation]
+        #   response object that represents the insertion operation.
+        def insert_server(instance_name, zone, options = {})
+          zone = zone.split("/")[-1]
+
+          data = options.merge(:name => instance_name)
+          data[:disks] = process_disks(options[:disks])
+          data[:network_interfaces] = process_network_interfaces(options[:network_interfaces])
+
+          machine_type = options[:machine_type]
+          unless machine_type
+            raise ArgumentError.new("machine type is required")
+          end
+
+          unless machine_type.include?("zones/")
+            machine_type = "zones/#{zone}/machineTypes/#{data[:machine_type]}"
+          end
+          data[:machine_type] = machine_type
+
+          # Optional subclassed attributes
+          if data[:guest_accelerators]
+            data[:guest_accelerators] = data[:guest_accelerators].map do |acc_config|
+              ::Google::Apis::ComputeV1::AcceleratorConfig.new(acc_config)
+            end
+          end
+
+          if data[:metadata]
+            data[:metadata] = ::Google::Apis::ComputeV1::Metadata.new(options[:metadata])
+          end
+
+          if data[:scheduling]
+            data[:scheduling] = ::Google::Apis::ComputeV1::Scheduling.new(options[:scheduling])
+          end
+
+          if data[:shielded_instance_config]
+            data[:shielded_instance_config] = ::Google::Apis::ComputeV1::ShieldedInstanceConfig.new(options[:shielded_instance_config])
+          end
+
+          if data[:tags]
+            if options[:tags].is_a?(Array)
+              # Process classic tag notation, i.e. ["fog"]
+              data[:tags] = ::Google::Apis::ComputeV1::Tags.new({ :items => options[:tags] })
+            else
+              data[:tags] = ::Google::Apis::ComputeV1::Tags.new(options[:tags])
+            end
+          end
+
+          instance = ::Google::Apis::ComputeV1::Instance.new(data)
+          @compute.insert_instance(@project, zone, instance)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_ssl_certificate.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_ssl_certificate(_certificate_name, _certificate, _private_key, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_ssl_certificate(certificate_name, certificate, private_key, description: nil)
+          @compute.insert_ssl_certificate(
+            @project,
+            ::Google::Apis::ComputeV1::SslCertificate.new(
+              :certificate => certificate,
+              :name => certificate_name,
+              :private_key => private_key,
+              :description => description
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_subnetwork.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_subnetwork(_subnetwork_name, _region_name, _network, _ip_range, _options = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        ##
+        # Create a subnetwork.
+        #
+        # @param subnetwork_name [String] the name of the subnetwork
+        # @param region_name [String] the name of the subnetwork's region
+        # @param network [String] URL of the network this subnetwork belongs to
+        # @param ip_range [String] The range of internal addresses that are owned
+        #   by this subnetwork.
+        # @param options [Hash] Other optional attributes to set on the subnetwork
+        # @option options [Boolean] private_ip_google_access Whether the VMs in
+        #   this subnet can access Google services without assigned external IP
+        #   addresses.
+        # @option options [String] description An optional description of this resource.
+        # @option options [Array<Hash>] secondary_ip_ranges An array of configurations
+        #   for secondary IP ranges
+        # @option secondary_ip_ranges [String] ip_cidr_range The range of IP
+        #   addresses for a secondary range
+        # @option secondary_ip_ranges [String] range_name The name associated
+        #   with a secondary range
+        #
+        # @return [Google::Apis::ComputeV1::Operation] an operation response
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/subnetworks/insert
+        def insert_subnetwork(subnetwork_name, region_name, network, ip_range, options = {})
+          region_name = region_name.split("/")[-1] if region_name.start_with? "http"
+          unless network.start_with? "http"
+            network = "#{@api_url}#{@project}/global/networks/#{network}"
+          end
+
+          params = {
+            :name => subnetwork_name,
+            :ip_cidr_range => ip_range,
+            :region => region_name,
+            :network => network
+          }
+
+          optional_fields = %i{private_ip_google_access description secondary_ip_ranges}
+          params = optional_fields.inject(params) do |data, field|
+            data[field] = options[field] unless options[field].nil?
+            data
+          end
+
+          subnetwork = ::Google::Apis::ComputeV1::Subnetwork.new(params)
+          @compute.insert_subnetwork(@project, region_name, subnetwork)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_target_http_proxy.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_target_http_proxy(_proxy_name, _description: nil, _url_map: nil)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_target_http_proxy(proxy_name, description: nil, url_map: nil)
+          @compute.insert_target_http_proxy(
+            @project,
+            ::Google::Apis::ComputeV1::TargetHttpProxy.new(
+              :name => proxy_name,
+              :description => description,
+              :url_map => url_map
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_target_https_proxy.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_target_https_proxy(_proxy_name, _description: nil,
+                                      _url_map: nil, _ssl_certificates: nil)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_target_https_proxy(proxy_name, description: nil,
+                                      url_map: nil, ssl_certificates: nil)
+          @compute.insert_target_https_proxy(
+            @project,
+            ::Google::Apis::ComputeV1::TargetHttpsProxy.new(
+              :name => proxy_name,
+              :description => description,
+              :url_map => url_map,
+              :ssl_certificates => ssl_certificates
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_target_instance.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_target_instance(_target_name, _zone, _target_instance = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_target_instance(target_name, zone, target_instance = {})
+          zone = zone.split("/")[-1] if zone.start_with? "http"
+          @compute.insert_target_instance(
+            @project, zone,
+            ::Google::Apis::ComputeV1::TargetInstance.new(
+              target_instance.merge(:name => target_name)
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/insert_target_pool.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def insert_target_pool(_target_pool_name, _region, _target_pool = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def insert_target_pool(target_pool_name, region, target_pool = {})
+          pool_obj = ::Google::Apis::ComputeV1::TargetPool.new(
+            target_pool.merge(:name => target_pool_name)
+          )
+          @compute.insert_target_pool(@project, region.split("/")[-1], pool_obj)
+        end
+      end
+    end
+  end
+end