fog-google 0.6.0 → 1.0.0

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

@@ -2,57 +2,24 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_forwarding_rule(name, region_name, opts = {})
-          # check that region exists
-          get_region(region_name)
-
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:forwarding_rules][name] = {
-            "kind" => "compute#forwardingRule",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => name,
-            "description" => "",
-            "region" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}",
-            "IPAddress" => "",
-            "IPProtocol" => "",
-            "portRange" => "",
-            "target" => opts["target"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/forwardingRules/#{name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "region" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/forwardingRules/#{name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{region_name}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_forwarding_rule(_rule_name, _region, _opts = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_forwarding_rule(forwarding_rule_name, region_name, opts = {})
-          api_method = @compute.forwarding_rules.insert
-          parameters = {
-            "project" => @project,
-            "region" => region_name
-          }
-          body_object = { "name" => forwarding_rule_name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object = body_object)
+        ##
+        # Create a forwarding rule.
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/forwardingRules/insert
+        def insert_forwarding_rule(rule_name, region, opts = {})
+          region = region.split("/")[-1] if region.start_with? "http"
+          @compute.insert_forwarding_rule(
+            @project, region,
+            ::Google::Apis::ComputeV1::ForwardingRule.new(
+              opts.merge(:name => rule_name)
+            )
+          )
         end
       end
     end

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

@@ -8,15 +8,14 @@ module Fog
       end
 
       class Real
-        def insert_global_address(address_name, options = {})
-          api_method = @compute.global_addresses.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => address_name }
-          body_object["description"] = options[:description] if options[:description]
+        INSERTABLE_ADDRESS_FIELDS = %i{description ip_version}.freeze
 
-          request(api_method, parameters, body_object)
+        def insert_global_address(address_name, options = {})
+          opts = options.select { |k, _| INSERTABLE_ADDRESS_FIELDS.include? k }
+                        .merge(:name => address_name)
+          @compute.insert_global_address(
+            @project, ::Google::Apis::ComputeV1::Address.new(opts)
+          )
         end
       end
     end

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

@@ -2,53 +2,21 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_global_forwarding_rule(name, opts = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:global_forwarding_rules][name] = {
-            "kind" => "compute#forwardingRule",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => name,
-            "description" => "",
-            "region" => "global",
-            "IPAddress" => "",
-            "IPProtocol" => "",
-            "portRange" => "",
-            "target" => opts["target"],
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/forwardingRules/#{name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/forwardingRules/#{name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_global_forwarding_rule(_rule_name, _opts = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_global_forwarding_rule(global_forwarding_rule_name, opts = {})
-          api_method = @compute.global_forwarding_rules.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = { "name" => global_forwarding_rule_name, "region" => "global" }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object = body_object)
+        ##
+        # Create a global forwarding rule.
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/globalForwardingRules/insert
+        def insert_global_forwarding_rule(rule_name, opts = {})
+          opts = opts.merge(:name => rule_name)
+          @compute.insert_global_forwarding_rule(
+            @project, ::Google::Apis::ComputeV1::ForwardingRule.new(opts)
+          )
         end
       end
     end

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

@@ -2,56 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_http_health_check(name, _options = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:http_health_checks][name] = {
-            "kind" => "compute#httpHealthCheck",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "name" => name,
-            "description" => "",
-            "host" => "0.00.0.0",
-            "requestPath" => "/",
-            "port" => 80,
-            "checkIntervalSec" => 5,
-            "timeoutSec" => 5,
-            "unhealthyThreshold" => 2,
-            "healthyThreshold" => 2,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/httpHealthChecks/#{name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/httpHealthChecks/#{name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_http_health_check(_check_name, _options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_http_health_check(name, opts = {})
-          api_method = @compute.http_health_checks.insert
-          parameters = {
-            "project" => @project
-          }
-
-          body_object = { "name" => name }
-          body_object.merge!(opts)
-
-          request(api_method, parameters, body_object)
+        def insert_http_health_check(check_name, opts = {})
+          @compute.insert_http_health_check(
+            @project,
+            ::Google::Apis::ComputeV1::HttpHealthCheck.new(
+              opts.merge(:name => check_name)
+            )
+          )
         end
       end
     end

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

@@ -2,61 +2,18 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_image(image_name, options = {})
-          id = Fog::Mock.random_numbers(19).to_s
-          object = {
-            "kind" => "compute#image",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "sourceType" => "",
-            "rawDisk" => {
-              "source" => options ["source"],
-              "shal1Checksum" => "",
-              "containerType" => ""
-            },
-            "status" => "READY",
-            "name" => image_name,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/images/#{image_name}"
-          }
-          data[:images][image_name] = object
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "operationType" => "insert",
-            "targetLink" => object["selfLink"],
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_image(_image_name, _image = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_image(image_name, options = {})
-          api_method = @compute.images.insert
-
-          parameters = {
-            "project" => @project
-          }
-
-          body_object = {
-            "sourceType"      => "RAW",
-            "name"            => image_name
-          }
-
-          # Merge in the remaining params
-          body_object.merge!(options)
-
-          request(api_method, parameters, body_object = body_object)
+        def insert_image(image_name, image = {}, project = @project)
+          image = image.merge(:name => image_name)
+          @compute.insert_image(
+            project,
+            ::Google::Apis::ComputeV1::Image.new(image)
+          )
         end
       end
     end

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

@@ -9,28 +9,25 @@ module Fog
 
       class Real
         def insert_instance_group(group_name, zone, options = {})
-          api_method = @compute.instance_groups.insert
-          parameters = {
-            "project" => @project,
-            "zone" => zone
-          }
-
-          id = Fog::Mock.random_numbers(19).to_s
-
-          body = {
-            "name" => group_name
-          }
+          if options["network"]
+            network_name = last_url_segment(options["network"])
+          else
+            network_name = GOOGLE_COMPUTE_DEFAULT_NETWORK
+          end
 
-          body["description"] = options["description"] if options["description"]
-          network_name = options["network"] ? options["network"].split("/")[-1] : GOOGLE_COMPUTE_DEFAULT_NETWORK
-          body["network"] = "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/#{network_name}"
+          instance_group = ::Google::Apis::ComputeV1::InstanceGroup.new(
+            :description => options["description"],
+            :name => group_name,
+            :network => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/#{network_name}"
+          )
 
-          unless options["subnetwork"].nil?
-            subnetwork_name = options["subnetwork"].split("/")[-1]
-            body["subnetwork"] = "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/regions/#{@region}/subnetworks/#{subnetwork_name}"
-          end
+          @compute.insert_instance_group(@project,
+                                         last_url_segment(zone),
+                                         instance_group)
+        end
 
-          request(api_method, parameters, body)
+        def last_url_segment(network)
+          network.split("/")[-1]
         end
       end
     end

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

@@ -2,26 +2,29 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_network(_network_name, _ip_range, _options = {})
+        def insert_network(_network_name, _opts = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_network(network_name, ip_range, options = {})
-          api_method = @compute.networks.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = {
-            "name" => network_name,
-            "IPv4Range" => ip_range
-          }
+        INSERTABLE_NETWORK_FIELDS = %i{
+          auto_create_subnetworks
+          description
+          gateway_i_pv4
+          i_pv4_range
+          name
+          routing_config
+        }.freeze
 
-          body_object["description"] = options[:description] if options[:description]
-          body_object["gatewayIPv4"] = options[:gateway_ipv4] if options[:gateway_ipv4]
+        def insert_network(network_name, opts = {})
+          opts = opts.select { |k, _| INSERTABLE_NETWORK_FIELDS.include? k }
+                     .merge(:name => network_name)
 
-          request(api_method, parameters, body_object)
+          @compute.insert_network(
+            @project,
+            ::Google::Apis::ComputeV1::Network.new(opts)
+          )
         end
       end
     end

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

@@ -2,32 +2,30 @@ module Fog
   module Compute
     class Google
       class Mock
-        def insert_route(_name, _network, _dest_range, _priority, _options = {})
+        def insert_route(_route_name, _network, _dest_range, _priority, _options = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def insert_route(name, network, dest_range, priority, options = {})
-          api_method = @compute.routes.insert
-          parameters = {
-            "project" => @project
-          }
-          body_object = {
-            "name" => name,
-            "network" => network,
-            "destRange" => dest_range,
-            "priority" => priority
-          }
-          body_object["description"] = options[:description] if options[:description]
-          unless options[:tags].nil? || options[:tags].empty?
-            body_object["tags"] = options[:tags]
-          end
-          body_object["nextHopInstance"] = options[:next_hop_instance] if options[:next_hop_instance]
-          body_object["nextHopGateway"] = options[:next_hop_gateway] if options[:next_hop_gateway]
-          body_object["nextHopIp"] = options[:next_hop_ip] if options[:next_hop_ip]
+        # 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]
+          )
 
-          request(api_method, parameters, body_object)
+          @compute.insert_route(@project, route)
         end
       end
     end

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

@@ -2,269 +2,108 @@ module Fog
   module Compute
     class Google
       class Mock
-        include Shared
-
-        def handle_disks(options, zone_name)
-          disks = []
-          i = 0
-          options.delete("disks").each do |disk|
-            disk = Disk.new(disk) unless disk.is_a? Disk
-            disks << {
-              "kind" => "compute#attachedDisk",
-              "index" => i,
-              "type" => "PERSISTENT",
-              "mode" => "READ_WRITE",
-              "source" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/disks/#{disk.name}",
-              "deviceName" => "persistent-disk-#{i}",
-              "boot" => true
-            }
-            i += 1
-          end
-          disks
-        end
-
-        # (see Fog::Compute::Google::Real#insert_server)
-        def insert_server(server_name, zone_name, options = {}, *_deprecated_args)
-          # check that zone exists
-          get_zone(zone_name)
-
-          if options["disks"].nil? || options["disks"].empty?
-            raise ArgumentError.new "Empty value for field 'disks'. Boot disk must be specified"
-          end
-          id = Fog::Mock.random_numbers(19).to_s
-          data[:servers][server_name] = {
-            "kind" => "compute#instance",
-            "id" => id,
-            "creationTimestamp" => Time.now.iso8601,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}",
-            "status" => "PROVISIONING",
-            "name" => server_name,
-            "tags" => { "fingerprint" => "42WmSpB8rSM=" },
-            "machineType" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/machineTypes/#{options['machineType']}",
-            "canIpForward" => false,
-            "networkInterfaces" => [
-              {
-                "network" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/global/networks/default",
-                "networkIP" => Fog::Mock.random_ip,
-                "name" => "nic0",
-                "accessConfigs" => [
-                  {
-                    "kind" => "compute#accessConfig",
-                    "type" => "ONE_TO_ONE_NAT",
-                    "name" => "External NAT",
-                    "natIP" => Fog::Mock.random_ip
-                  }
-                ]
-              }
-            ],
-            "disks" => handle_disks(options, zone_name),
-            "metadata" => {
-              "kind" => "compute#metadata",
-              "fingerprint" => "5_hasd_gC3E=",
-              "items" => [
-                {
-                  "key" => "ssh-keys",
-                  "value" => "sysadmin:ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAgEA1zc7mx+0H8Roywet/L0aVX6MUdkDfzd/17kZhprAbpUXYOILv9AG4lIzQk6xGxDIltghytjfVGme/4A42Sb0Z9LN0pxB4KnWTNoOSHPJtp6jbXpq6PdN9r3Z5NKQg0A/Tfw7gt2N0GDsj6vpK8VbHHdW78JAVUxql18ootJxjaksdocsiHNK8iA6/v9qiLRhX3fOgtK7KpxxdZxLRzFg9vkp8jcGISgpZt27kOgXWhR5YLhi8pRJookzphO5O4yhflgoHoAE65XkfrsRCe0HU5QTbY2jH88rBVkq0KVlZh/lEsuwfmG4d77kEqaCGGro+j1Wrvo2K3DSQ+rEcvPp2CYRUySjhaeLF18UzQLtxNeoN14QOYqlm9ITdkCnmq5w4Wn007MjSOFp8LEq2RekrnddGXjg1/vgmXtaVSGzJAlXwtVfZor3dTRmF0JCpr7DsiupBaDFtLUlGFFlSKmPDVMPOOB5wajexmcvSp2Vu4U3yP8Lai/9/ZxMdsGPhpdCsWVL83B5tF4oYj1HVIycbYIxIIfFqOxZcCru3CMfe9jmzKgKLv2UtkfOS8jpS/Os2gAiB3wPweH3agvtwYAYBVMDwt5cnrhgHYWoOz7ABD8KgmCrD7Y9HikiCqIUNkgUFd9YmjcYi5FkU5rFXIawN7efs341lsdf923lsdf923fs= johndoe@acme"
-                }
-              ]
-            },
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/instances/#{server_name}"
-          }
-
-          operation = random_operation
-          data[:operations][operation] = {
-            "kind" => "compute#operation",
-            "id" => Fog::Mock.random_numbers(19).to_s,
-            "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}",
-            "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/instances/#{server_name}",
-            "targetId" => id,
-            "status" => Fog::Compute::Google::Operation::PENDING_STATE,
-            "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
-            "progress" => 0,
-            "insertTime" => Time.now.iso8601,
-            "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/operations/#{operation}"
-          }
-
-          build_excon_response(data[:operations][operation])
+        def insert_server(_instance_name, _zone, _options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        include Shared
-
-        def handle_disks(options)
-          disks = []
-          # An array of persistent disks. You must supply a boot disk as the first disk in
-          # this array and mark it as a boot disk using the disks[].boot property.
-          options.delete("disks").each do |disk|
-            if disk.is_a? Disk
-              disks << disk.get_object
-            else
-              disks << disk
-            end
-          end
-          disks.first["boot"] = true
-          disks
+        def default_network_interface
+          { :network => "global/networks/#{GOOGLE_COMPUTE_DEFAULT_NETWORK}" }
         end
 
-        def handle_networks(options, region_name)
-          # Only one access config, ONE_TO_ONE_NAT, is supported per instance.
-          # If there are no accessConfigs specified, then this instance will have no external internet access.
-          access_config = { "type" => "ONE_TO_ONE_NAT", "name" => "External NAT" }
-          # If natIP is undefined VM will get an IP from a shared ephemeral IP address pool
-          if options.key? "externalIp"
-            access_config["natIP"] = options.delete "externalIp"
-            # If :external_ip is set to 'false', do not allow _any_ external networking
-            access_config = nil if access_config["natIP"] == false
+        def process_disks(disks)
+          unless disks && !disks.empty?
+            raise ArgumentError.new("at least one value for disks is required")
           end
 
-          # If no networking options are specified, assume default network
-          if options.key? "network"
-            network = options.delete "network"
-          else
-            network = GOOGLE_COMPUTE_DEFAULT_NETWORK
+          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
 
-          # Objectify the network if needed
-          unless network.is_a?(Network)
-            network = networks.get(network)
+        def process_network_interfaces(network_interfaces)
+          unless network_interfaces && !network_interfaces.empty?
+            network_interfaces = [default_network_interface]
           end
-
-          network_interfaces = network.get_as_interface_config(access_config)
-
-          if options.key? "subnetwork"
-            subnetwork = options.delete "subnetwork"
-            # Objectify the subnetwork if needed
-            unless subnetwork.is_a?(Subnetwork)
-              subnetwork = subnetworks.get(subnetwork, region_name)
-            end
-            network_interfaces = subnetwork.update_interface_config(network_interfaces)
+          network_interfaces.map do |network|
+            ::Google::Apis::ComputeV1::NetworkInterface.new(network)
           end
-
-          # Return a networkInterfaces array
-          [network_interfaces]
-        end
-
-        def format_metadata(metadata)
-          { "items" => metadata.map { |k, v| { "key" => k, "value" => v } } }
         end
 
         ##
-        # Create a new instance (virtual machine). You can provision a server
-        # using low-level request options via this method (if you don't need to
-        # modify low-level request options, consider using the 'servers'
-        # collection object instead - see Fog::Compute::Google::Servers).
-        # This method should directly take any of the API parameters/options for
-        # the GCP endpoint (passed through the +options+ parameter).
+        # 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.
         #
-        # @see https://cloud.google.com/compute/docs/reference/latest/instances/insert
         # @example minimal server creation
-        #   require 'fog/google'
-        #   client = Fog::Compute::Google.new
-        #   my_result = client.insert_server('my-server',
-        #                                    'us-central1-b',
-        #                                    'machineType' => 'f1-micro',
-        #                                     'disks' => [
-        #                                       'initializeParams' => {
-        #                                         'sourceImage' => 'projects/debian-cloud/global/images/family/debian-8'
-        #                                       }
-        #                                     ])
+        #     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-8"
+        #           }
+        #         }
+        #       ]
+        #     )
         #
-        # @param server_name [String] Name to assign to the created server. Must
-        #   be unique within the specified zone.
-        # @param zone_name [String] Name of zone containing the created server.
-        #   See Fog::Compute::Google#zones for a list of available zones.
-        # @param options [Hash] options to use when creating a server. You can
-        #  use any of the options documented at
-        #  https://cloud.google.com/compute/docs/reference/latest/instances/insert.
-        #  Additionally accepts some nonstandard parameters documented below.
-        # @option options [String] 'machineType' Required: the machine type to use - see
-        #   https://cloud.google.com/compute/docs/machine-types for a list.
-        # @option options [String] 'externalIp' An IP address to assign to the
-        #   server. See
-        #   https://cloud.google.com/compute/docs/configure-instance-ip-addresses
-        #   for more information about assigning instance ip addresses.
-        # @option options [Boolean] 'auto_restart' (false) if true, then the
-        #   server will be automatically restarted if terminated by Google Compute
-        #   Engine. Note that this value cannot be set to true if the VM is
-        #   preemptible.
-        # @option options [Boolean] 'preemptible' (false) if true, then the
-        #   created server will be preemptible and therefore only run for at
-        #   most 24 hours. See
-        #   https://cloud.google.com/compute/docs/instances/preemptible for more
-        #   information about preemptible instances.
-        # @option options ["MIGRATE", "TERMINATE"] 'on_host_maintenance' if
-        #   "MIGRATE", then the VM will be migrated to different hardware during
-        #   a maintenance event. If "TERMINATE", then the VM will be terminated.
-        #   Note that if the VM is preemptible, then this option MUST be
-        #   "TERMINATE".
-        # @option options [Boolean] 'can_ip_forward' (false) if true, then the
-        #   created instance will allow forwarding packets that don't originate
-        #   with the assigned host ip address. See
-        #   https://cloud.google.com/compute/docs/networking#canipforward for
-        #   more information.
-        # @return [Excon::Response] response object that represents the result.
-        def insert_server(server_name, zone_name, options = {}, *deprecated_args)
-          if !deprecated_args.empty? || !options.is_a?(Hash)
-            raise ArgumentError.new "Too many parameters specified. This may be the cause of code written for an outdated"\
-                " version of fog. Usage: server_name, zone_name, [options]"
+        # @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
-          api_method = @compute.instances.insert
-          parameters = {
-            "project" => @project,
-            "zone" => zone_name
-          }
-          body_object = { :name => server_name }
-
-          body_object["machineType"] = @api_url + @project + "/zones/#{zone_name}/machineTypes/#{options.delete 'machineType'}"
 
-          scheduling = {
-            "automaticRestart" => false,
-            "onHostMaintenance" => "MIGRATE",
-            "preemptible" => false
-          }
-          if options.key? "auto_restart"
-            scheduling["automaticRestart"] = options.delete "auto_restart"
-            scheduling["automaticRestart"] = scheduling["automaticRestart"].class == TrueClass
+          unless machine_type.include?("zones/")
+            machine_type = "zones/#{zone}/machineTypes/#{data[:machine_type]}"
           end
-          if options.key? "preemptible"
-            scheduling["preemptible"] = options.delete "preemptible"
-            scheduling["preemptible"] = scheduling["preemptible"].class == TrueClass
-            # If we don't have an explicit value for "on_host_maintenance, then
-            # force the value to be 'TERMINATE' as it's the default and
-            # only-accepted value for preemptible vms
-            scheduling["onHostMaintenance"] = "TERMINATE" unless options.key? "on_host_maintenance"
-          end
-          if options.key? "on_host_maintenance"
-            ohm = options.delete "on_host_maintenance"
-            scheduling["onHostMaintenance"] = (ohm.respond_to?("upcase") &&
-                    ohm.upcase == "MIGRATE" && "MIGRATE") || "TERMINATE"
-          end
-          body_object["scheduling"] = scheduling
+          data[:machine_type] = machine_type
 
-          # @see https://developers.google.com/compute/docs/networking#canipforward
-          if options.key? "can_ip_forward"
-            body_object["canIpForward"] = options.delete "can_ip_forward"
+          # 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
 
-          # TODO: add other networks
-          body_object["networkInterfaces"] = handle_networks(options, get_zone(zone_name).body["region"].split("/")[-1])
-
-          if options["disks"].nil? || options["disks"].empty?
-            raise ArgumentError.new "Empty value for field 'disks'. Boot disk must be specified"
+          if data[:metadata]
+            data[:metadata] = ::Google::Apis::ComputeV1::Metadata.new(options[:metadata])
           end
-          body_object["disks"] = handle_disks(options)
 
-          options["metadata"] = format_metadata options["metadata"] if options["metadata"]
-
-          body_object["tags"] = { "items" => options.delete("tags") } if options["tags"]
+          if data[:scheduling]
+            data[:scheduling] = ::Google::Apis::ComputeV1::ServiceAccount.new(options[:scheduling])
+          end
 
-          body_object.merge!(options) # Adds in all remaining options that weren't explicitly handled.
+          if data[:tags]
+            data[:tags] = ::Google::Apis::ComputeV1::Tags.new(options[:tags])
+          end
 
-          request(api_method, parameters, body_object = body_object)
+          instance = ::Google::Apis::ComputeV1::Instance.new(data)
+          @compute.insert_instance(@project, zone, instance)
         end
       end
     end