fog-google 0.6.0 → 1.0.0

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

@@ -53,10 +53,10 @@ module Fog
           requires :identity, :zone
 
           instance_list = []
-          data = service.list_instance_group_instances(identity, zone_name).body
-          if data["items"]
-            data["items"].each do |instance|
-              instance_list << service.servers.get(instance["instance"].split("/")[-1], zone_name)
+          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

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

@@ -6,36 +6,38 @@ module Fog
 
         def all(filters = {})
           if filters[:zone]
-            data = service.list_instance_groups(filters[:zone]).body
+            data = Array(service.list_instance_groups(filters[:zone]))
           else
             data = []
-            service.list_aggregated_instance_groups.body["items"].each_value do |group|
-              data.concat(group["instanceGroups"]) if group["instanceGroups"]
+            service.list_aggregated_instance_groups.items.each_value do |group|
+              data.concat(group.instance_groups) if group.instance_groups
             end
           end
 
-          load(data)
+          load(data.map(&:to_h))
         end
 
         def get(identity, zone = nil)
           if zone.nil?
-            zones = service.list_aggregated_instance_groups(:filter => "name eq .*#{identity}").body["items"]
-            target_zone = zones.each_value.select { |zone| zone.key?("instanceGroups") }
-            response = target_zone.first["instanceGroups"].first unless target_zone.empty?
-            zone = response["zone"].split("/")[-1]
+            zones = service.list_aggregated_instance_groups(:filter => "name eq .*#{identity}").items
+            instance_groups = zones.each_value.map(&:instance_groups).compact.first
+            if instance_groups
+              zone = instance_groups.first.zone.split("/")[-1]
+            end
           end
 
-          if instance_group = service.get_instance_group(identity, zone).body
-            new(instance_group)
+          if instance_group = service.get_instance_group(identity, zone)
+            new(instance_group.to_h)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
 
         # TODO: 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.first})[/]"
+            "#{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])
@@ -44,7 +46,7 @@ module Fog
         # TODO: 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.first})[/]"
+            "#{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])

data/lib/fog/compute/google/models/{flavor.rb → machine_type.rb}

@@ -1,30 +1,22 @@
 module Fog
   module Compute
     class Google
-      class Flavor < Fog::Model
+      class MachineType < Fog::Model
         identity :name
 
-        attribute :kind
-        attribute :id
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :deprecated
         attribute :description
         attribute :guest_cpus, :aliases => "guestCpus"
-        attribute :image_space_gb, :aliases => "imageSpaceGb"
+        attribute :id
+        attribute :is_shared_cpu, :aliases => "isSharedCpu"
+        attribute :kind
         attribute :maximum_persistent_disks, :aliases => "maximumPersistentDisks"
-        attribute :maximum_persistent_disks_size, :aliases => "maximumPersistentDisksSizeGb"
+        attribute :maximum_persistent_disks_size_gb, :aliases => "maximumPersistentDisksSizeGb"
         attribute :memory_mb, :aliases => "memoryMb"
-        attribute :scratch_disks, aliases => "scratchDisks"
+        attribute :scratch_disks, :aliases => "scratchDisks"
         attribute :self_link, :aliases => "selfLink"
         attribute :zone
-
-        def reload
-          requires :identity, :zone
-
-          data = collection.get(identity, zone)
-          merge_attributes(data.attributes)
-          self
-        end
       end
     end
   end

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

@@ -0,0 +1,37 @@
+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)
+          machine_type = service.get_machine_type(identity, zone).to_h
+          return nil if machine_type.nil?
+          new(machine_type)
+        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

@@ -8,19 +8,24 @@ module Fog
       class Network < Fog::Model
         identity :name
 
-        attribute :kind
-        attribute :id
-        attribute :ipv4_range, :aliases => "IPv4Range"
-        attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :auto_create_subnetworks, aliases => "autoCreateSubnetworks"
+        attribute :creation_timestamp, aliases => "creationTimestamp"
         attribute :description
-        attribute :gateway_ipv4, :aliases => "gatewayIPv4"
-        attribute :self_link, :aliases => "selfLink"
+        attribute :gateway_ipv4, aliases => %w(gateway_i_pv4 gatewayIPv4)
+        attribute :ipv4_range, aliases => %w(i_pv4_range IPv4Range)
+        attribute :id
+        attribute :kind
+        attribute :peerings
+        attribute :routing_config, aliases => "routingConfig"
+        attribute :self_link, aliases => "selfLink"
+        attribute :subnetworks
 
         def save
           requires :identity, :ipv4_range
 
-          data = service.insert_network(identity, ipv4_range, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          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? }
@@ -31,15 +36,16 @@ module Fog
           requires :identity
 
           data = service.delete_network(identity)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          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["accessConfigs"] = [access_config] if access_config
+          network_interface = { :network => self_link }
+          network_interface[:access_configs] = [access_config] if access_config
           network_interface
         end
       end

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

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::Network
 
         def all
-          data = service.list_networks.body
-          load(data["items"] || [])
+          data = service.list_networks.to_h[:items]
+          load(data || [])
         end
 
         def get(identity)
-          if network = service.get_network(identity).body
+          if network = service.get_network(identity).to_h
             new(network)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -64,9 +64,9 @@ module Fog
           self
         end
 
-        PENDING_STATE = "PENDING"
-        RUNNING_STATE = "RUNNING"
-        DONE_STATE = "DONE"
+        PENDING_STATE = "PENDING".freeze
+        RUNNING_STATE = "RUNNING".freeze
+        DONE_STATE = "DONE".freeze
       end
     end
   end

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

@@ -4,15 +4,24 @@ module Fog
       class Operations < Fog::Collection
         model Fog::Compute::Google::Operation
 
-        def all(filters = {})
-          if filters["zone"]
-            data = service.list_zone_operations(filters["zone"]).body
-          elsif filters["region"]
-            data = service.list_region_operations(filters["region"]).body
+        def all(zone: nil, 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 zone
+            data = service.list_zone_operations(zone, opts).to_h[:items]
+          elsif region
+            data = service.list_region_operations(regions, opts).to_h[:items]
           else
-            data = service.list_global_operations.body
+            data = service.list_global_operations(opts).to_h[:items]
           end
-          load(data["items"] || [])
+
+          load(data || [])
         end
 
         def get(identity, zone = nil, region = nil)
@@ -23,9 +32,11 @@ module Fog
           else
             response = service.get_global_operation(identity)
           end
+
           return nil if response.nil?
-          new(response.body)
-        rescue Fog::Errors::NotFound
+          new(response.to_h)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -19,8 +19,8 @@ module Fog
         def set_metadata(metadata = {})
           requires :identity
 
-          data = service.set_common_instance_metadata(identity, common_instance_metadata["fingerprint"], metadata)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation = service.set_common_instance_metadata(identity, common_instance_metadata["fingerprint"], metadata)
+          Fog::Compute::Google::Operations.new(:service => service).get(operation.id)
         end
       end
     end

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

@@ -5,10 +5,11 @@ module Fog
         model Fog::Compute::Google::Project
 
         def get(identity)
-          if project = service.get_project(identity).body
+          if project = service.get_project(identity).to_h
             new(project)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -18,8 +18,8 @@ module Fog
         attribute :status
         attribute :zones
 
-        DOWN_STATE = "DOWN"
-        UP_STATE   = "UP"
+        DOWN_STATE = "DOWN".freeze
+        UP_STATE   = "UP".freeze
 
         def up?
           status == UP_STATE

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

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::Region
 
         def all
-          data = service.list_regions.body
-          load(data["items"] || [])
+          data = service.list_regions.to_h
+          load(data[:items] || [])
         end
 
         def get(identity)
-          if region = service.get_region(identity).body
+          if region = service.get_region(identity).to_h
             new(region)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -18,6 +18,7 @@ module Fog
         attribute :next_hop_instance, :aliases => "nextHopInstance"
         attribute :next_hop_ip, :aliases => "nextHopIp"
         attribute :next_hop_network, :aliases => "nextHopNetwork"
+        attribute :next_hop_vpn_tunnel, :aliases => "nextHopVpnTunnel"
         attribute :priority
         attribute :self_link, :aliases => "selfLink"
         attribute :tags
@@ -27,7 +28,8 @@ module Fog
           requires :identity, :network, :dest_range, :priority
 
           data = service.insert_route(identity, network, dest_range, priority, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -36,7 +38,8 @@ module Fog
           requires :identity
 
           data = service.delete_route(identity)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { ready? } unless async
           operation
         end

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

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::Route
 
         def all
-          data = service.list_routes.body
-          load(data["items"] || [])
+          data = service.list_routes.to_h
+          load(data[:items] || [])
         end
 
         def get(identity)
-          if route = service.get_route(identity).body
+          if route = service.get_route(identity).to_h
             new(route)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
       end

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

@@ -6,301 +6,488 @@ module Fog
       class Server < Fog::Compute::Server
         identity :name
 
-        attribute :kind
-        attribute :id
+        # @return [Boolean]
         attribute :can_ip_forward, :aliases => "canIpForward"
+
+        # @return [String]
+        attribute :cpu_platform, :aliases => "cpuPlatform"
+
+        # @return [String]
         attribute :creation_timestamp, :aliases => "creationTimestamp"
+
+        # @return [Boolean]
+        attribute :deletion_protection, :aliases => "deletionProtection"
+
+        # @return [String]
         attribute :description
+
+        # New disks may include :initialize_params before save.
+        #
+        # @example Minimal disks pre-creation:
+        #   [
+        #     {
+        #       :initialize_params => {
+        #         :source_image => "projects/debian-cloud/global/images/family/debian-8"
+        #       }
+        #     }
+        #   ]
+        #
+        # @example disks post-creation:
+        #   [
+        #     {
+        #       :auto_delete => false,
+        #       :boot => true,
+        #       :device_name => "persistent-disk-0",
+        #       :index => 0,
+        #       :interface => "SCSI",
+        #       :kind => "compute#attachedDisk",
+        #       :licenses => ["https://www.googleapis.com/compute/v1/..."],
+        #       :mode => "READ_WRITE",
+        #       :source => "https://www.googleapis.com/compute/v1/.../mydisk",
+        #       :type => "PERSISTENT"
+        #     }
+        #   ]
+        # @return [Array<Hash>]
         attribute :disks
+
+        # @example Guest accelerators
+        #   [
+        #     {
+        #       :accelerator_count => 1,
+        #       :accelerator_type => "...my/accelerator/type"
+        #     }
+        #   ]
+        # @return [Array<Hash>]
+        attribute :guest_accelerators, :aliases => "guestAccelerators"
+
+        # @return [Fixnum]
+        attribute :id
+
+        # @return [String]
+        attribute :kind
+
+        # @return [String]
+        attribute :label_fingerprint, :aliases => "labelFingerprint"
+
+        # @return [Hash<String,String>]
+        attribute :labels
+
+        # @return [String]
         attribute :machine_type, :aliases => "machineType"
+
+        # If set initially before save, the expected format
+        # is the API format as shown below.
+        #
+        # If you want to pass in a Hash, see {#set_metadata}.
+        # If you want to access the metadata items as a Hash, see
+        # {#metadata_as_h}.
+        #
+        # @example Metadata in API format
+        #
+        #   {
+        #     :fingerprint => "...",
+        #     :items => [
+        #       { :key => "foo", :value => "bar" },
+        #     ]
+        #   }
+        # @return [Hash]
         attribute :metadata
+
+        # @return [String]
+        attribute :min_cpu_platform, :aliases => "minCpuPlatform"
+
+        # @example Network interfaces
+        #   [
+        #     {
+        #       :kind => "compute#networkInterface",
+        #       :name => "nic0",
+        #       :network => "https://www.googleapis.com/compute/v1/.../my-network/"
+        #       :network_ip => "0.0.0.0",
+        #       :subnetwork => "https://www.googleapis.com/compute/v1/.../my-subnetwork"
+        #     }
+        #   ],
+        # @return [Array<Hash>]
         attribute :network_interfaces, :aliases => "networkInterfaces"
+
+        # @example Scheduling object
+        # {
+        #   :automatic_restart => true,
+        #   :on_host_maintenance => "MIGRATE",
+        #   :preemptible=>false
+        # }
+        # @return [Hash]
         attribute :scheduling
+
+        # @return [String]
         attribute :self_link, :aliases => "selfLink"
+
+        # @example Service accounts in API format
+        # [
+        #   {
+        #     :email => "my-service-account@developer.gserviceaccount.com",
+        #     :scopes => [],
+        #   }
+        # ]
+        # @return [Array<Hash>]
         attribute :service_accounts, :aliases => "serviceAccounts"
-        attribute :state, :aliases => "status"
+
+        # @return [Boolean]
+        attribute :start_restricted, :aliases => "startRestricted"
+
+        # @return [String]
+        attribute :status, :aliases => "status"
+
+        # @return [String]
         attribute :status_message, :aliases => "statusMessage"
+
+        # @example Tags in API format
+        # @return [Hash]
         attribute :tags
-        attribute :zone, :aliases => :zone_name
-
-        # These attributes are not available in the representation of an 'instance' returned by the GCE API.
-        # They are useful only for the create process
-        attribute :network, :aliases => "network"
-        attribute :subnetwork, :aliases => "subnetwork"
-        attribute :external_ip, :aliases => "externalIP"
-        attribute :auto_restart
-        attribute :on_host_maintenance
-        attribute :preemptible
-
-        # Security account scope aliases used by official gcloud utility
-        # List derived from 'gcloud compute instances create --help'
+
+        # @return [String]
+        attribute :zone
+
         GCE_SCOPE_ALIASES = {
-          "compute-ro" => "compute.readonly",
-          "compute-rw" => "compute",
-          "computeaccounts-ro" => "computeaccounts.readonly",
-          "computeaccounts-rw" => "computeaccounts",
-          "logging-write" => "logging.write",
-          "sql" => "sqlservice",
-          "sql-admin" => "sqlservice.admin",
-          "storage-full" => "devstorage.full_control",
-          "storage-ro" => "devstorage.read_only",
-          "storage-rw" => "devstorage.read_write"
-        }
-
-        def image_name=(_args)
-          Fog::Logger.deprecation("image_name= is no longer used [light_black](#{caller.first})[/]")
-        end
+          "default" => %w(
+            https://www.googleapis.com/auth/cloud.useraccounts.readonly
+            https://www.googleapis.com/auth/devstorage.read_only
+            https://www.googleapis.com/auth/logging.write
+            https://www.googleapis.com/auth/monitoring.write
+            https://www.googleapis.com/auth/pubsub
+            https://www.googleapis.com/auth/service.management.readonly
+            https://www.googleapis.com/auth/servicecontrol
+            https://www.googleapis.com/auth/trace.append
+          ),
+          "bigquery" => ["https://www.googleapis.com/auth/bigquery"],
+          "cloud-platform" => ["https://www.googleapis.com/auth/cloud-platform"],
+          "compute-ro" => ["https://www.googleapis.com/auth/compute.readonly"],
+          "compute-rw" => ["https://www.googleapis.com/auth/compute"],
+          "datastore" => ["https://www.googleapis.com/auth/datastore"],
+          "logging-write" => ["https://www.googleapis.com/auth/logging.write"],
+          "monitoring" => ["https://www.googleapis.com/auth/monitoring"],
+          "monitoring-write" => ["https://www.googleapis.com/auth/monitoring.write"],
+          "service-control" => ["https://www.googleapis.com/auth/servicecontrol"],
+          "service-management" => ["https://www.googleapis.com/auth/service.management.readonly"],
+          "sql" => ["https://www.googleapis.com/auth/sqlservice"],
+          "sql-admin" => ["https://www.googleapis.com/auth/sqlservice.admin"],
+          "storage-full" => ["https://www.googleapis.com/auth/devstorage.full_control"],
+          "storage-ro" => ["https://www.googleapis.com/auth/devstorage.read_only"],
+          "storage-rw" => ["https://www.googleapis.com/auth/devstorage.read_write"],
+          "taskqueue" => ["https://www.googleapis.com/auth/taskqueue"],
+          "useraccounts-ro" => ["https://www.googleapis.com/auth/cloud.useraccounts.readonly"],
+          "useraccounts-rw" => ["https://www.googleapis.com/auth/cloud.useraccounts"],
+          "userinfo-email" => ["https://www.googleapis.com/auth/userinfo.email"]
+        }.freeze
 
         def image_name
           boot_disk = disks.first
           unless boot_disk.is_a?(Disk)
-            source = boot_disk["source"]
+            source = boot_disk[:source]
             match = source.match(%r{/zones/(.*)/disks/(.*)$})
-            boot_disk = service.disks.get match[2], match[1]
+            boot_disk = service.disks.get(match[2], match[1])
           end
           boot_disk.source_image.nil? ? nil : boot_disk.source_image
         end
 
-        def kernel=(_args)
-          Fog::Logger.deprecation("kernel= is no longer used [light_black](#{caller.first})[/]")
-        end
-
-        def kernel
-          Fog::Logger.deprecation("kernel is no longer used [light_black](#{caller.first})[/]")
-          nil
-        end
-
-        def flavor_id
-          machine_type
-        end
-
-        def flavor_id=(flavor_id)
-          machine_type = flavor_id
-        end
-
         def destroy(async = true)
           requires :name, :zone
 
           data = service.delete_server(name, zone_name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
           operation.wait_for { ready? } unless async
           operation
         end
 
-        # not used since v1
-        def image
-          Fog::Logger.deprecation("Server.image is deprecated, get source_image from boot disk")
-          service.get_image(image_name.split("/")[-1])
-        end
-
-        def public_ip_address
-          ip = nil
-          if network_interfaces.respond_to? :each
-            network_interfaces.each do |netif|
-              next unless netif["accessConfigs"].respond_to? :each
-              netif["accessConfigs"].each do |access_config|
-                if access_config["name"] == "External NAT"
-                  ip = access_config["natIP"]
-                end
+        def public_ip_addresses
+          addresses = []
+          if network_interfaces.respond_to? :flatMap
+            addresses = network_interfaces.flatMap do |nic|
+              if nic[:access_configs].respond_to? :each
+                nic[:access_configs].select { |config| config[:name] == "External NAT" }
+                                    .map { |config| config[:nat_ip] }
+              else
+                []
               end
             end
           end
-
-          ip
+          addresses
         end
 
-        def private_ip_address
-          ip = nil
-          if network_interfaces.respond_to? :first
-            ip = network_interfaces.first["networkIP"]
+        def private_ip_addresses
+          addresses = []
+          if network_interfaces.respond_to? :map
+            addresses = network_interfaces.map { |nic| nic[:network_ip] }
           end
-          ip
+          addresses
         end
 
         def addresses
-          [private_ip_address, public_ip_address]
+          private_ip_addresses + public_ip_addresses
         end
 
-        def attach_disk(disk, options = {})
+        def attach_disk(disk, async = true, options = {})
           requires :identity, :zone
 
-          data = service.attach_disk(identity, zone_name, disk, options)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          if disk.is_a? Disk
+            disk_obj = disk.get_attached_disk
+          elsif disk.is_a? String
+            disk_obj = service.disks.attached_disk_obj(disk, options)
+          end
+
+          data = service.attach_disk(identity, zone_name, disk_obj)
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
-        def detach_disk(device_name)
+        def detach_disk(device_name, async = true)
           requires :identity, :zone
 
           data = service.detach_disk(identity, zone, device_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        # Returns metadata items as a Hash.
+        # @return [Hash<String, String>] items
+        def metadata_as_h
+          if metadata.nil? || metadata[:items].nil? || metadata[:items].empty?
+            return {}
+          end
+
+          Hash[metadata[:items].map { |item| [item[:key], item[:value]] }]
         end
 
-        def reboot
+        def reboot(async = true)
           requires :identity, :zone
 
           data = service.reset_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          operation
         end
 
-        def start
+        def start(async = true)
           requires :identity, :zone
 
           data = service.start_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          operation
         end
 
-        def stop
+        def stop(async = true)
           requires :identity, :zone
 
           data = service.stop_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          operation
         end
 
         def serial_port_output
           requires :identity, :zone
 
-          data = service.get_server_serial_port_output(identity, zone_name)
-          data.body["contents"]
+          service.get_server_serial_port_output(identity, zone_name).to_h[:contents]
         end
 
-        def set_disk_auto_delete(auto_delete, device_name = nil)
+        def set_disk_auto_delete(auto_delete, device_name = nil, async = true)
           requires :identity, :zone
 
-          unless device_name
-            if disks.count <= 1
-              device_name = disks[0]["deviceName"]
-            else
-              raise ArgumentError.new("Device name required if multiple disks are attached")
-            end
+          if device_name.nil? && disks.count > 1
+            raise ArgumentError.new("Device name is required if multiple disks are attached")
           end
 
-          data = service.set_server_disk_auto_delete(identity, zone_name, auto_delete, device_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          device_name ||= disks.first[:device_name]
+          data = service.set_server_disk_auto_delete(
+            identity, zone_name, auto_delete, device_name
+          )
+
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
-        def set_scheduling(on_host_maintenance, automatic_restart, preemptible)
+        def set_scheduling(async = true,
+                           on_host_maintenance: nil,
+                           automatic_restart: nil,
+                           preemptible: nil)
           requires :identity, :zone
-
-          data = service.set_server_scheduling(identity, zone_name, on_host_maintenance, automatic_restart, preemptible)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          data = service.set_server_scheduling(
+            identity, zone_name,
+            :on_host_maintenance => on_host_maintenance,
+            :automatic_restart => automatic_restart,
+            :preemptible => preemptible
+          )
+
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
-        def set_metadata(metadata = {})
+        def set_metadata(new_metadata = {}, async = true)
           requires :identity, :zone
 
-          data = service.set_metadata(identity, zone_name, self.metadata["fingerprint"], metadata)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          if new_metadata[:items] && new_metadata[:items].is_a?(Hash)
+            new_metadata[:items] = new_metadata[:items].map { |k, v| { :key => k, :value => v } }
+          end
+
+          data = service.set_server_metadata(
+            identity, zone_name, metadata[:fingerprint], new_metadata
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
-        def set_tags(tags = [])
+        def set_tags(new_tags = [], async = true)
           requires :identity, :zone
 
-          data = service.set_tags(identity, zone_name, self.tags["fingerprint"], tags)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          data = service.set_server_tags(
+            identity, zone_name, tags[:fingerprint], new_tags
+          )
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
         def provisioning?
-          state == PROVISIONING
+          status == PROVISIONING
         end
 
         def ready?
-          state == RUNNING
+          status == RUNNING
         end
 
         def zone_name
           zone.nil? ? nil : zone.split("/")[-1]
         end
 
-        def add_ssh_key(username, key)
-          set_metadata(generate_ssh_key_metadata(username, key))
-        end
-
-        def map_service_accounts(scope_array)
-          scope_array_expanded = scope_array.map do |e|
-            if GCE_SCOPE_ALIASES[e]
-              GCE_SCOPE_ALIASES[e]
-            else
-              e
-            end
-          end
+        def add_ssh_key(username, key, async = true)
+          metadata = generate_ssh_key_metadata(username, key)
 
-          scope_array_finalized = scope_array_expanded.map do |e|
-            if e.start_with?("https://")
-              e
-            else
-              "https://www.googleapis.com/auth/#{e}"
-            end
-          end
+          data = service.set_server_metadata(
+            identity, zone_name, metadata[:fingerprint], metadata[:items]
+          )
 
-          scope_array_finalized
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
+          operation.wait_for { ready? } unless async
+          reload
         end
 
         def reload
-          data = service.get_server(name, zone_name).body
+          data = service.get_server(name, zone_name).to_h
           merge_attributes(data)
         end
 
-        def save
+        def map_scopes(scopes)
+          return [] if scopes.nil?
+          scopes.flat_map do |scope|
+            if GCE_SCOPE_ALIASES.key? scope
+              # Expand scope alias to list of related scopes
+              GCE_SCOPE_ALIASES[scope]
+            else
+              [scope_url(scope)]
+            end
+          end
+        end
+
+        def save(username: nil, public_key: nil)
           requires :name
           requires :machine_type
-          requires :zone_name
           requires :disks
+          requires :zone
+
+          generate_ssh_key_metadata(username, public_key) if public_key
 
-          unless service.zones.detect { |zone| zone.name == zone_name }
-            raise ArgumentError.new "#{zone_name.inspect} is either down or you don't have permission to use it."
+          options = attributes.reject { |_, v| v.nil? }
+
+          if service_accounts && service_accounts[:scopes]
+            options[:service_accounts] = service_accounts.merge(
+              :scopes => map_scopes(service_accounts[:scopes])
+            )
           end
 
-          generate_ssh_key_metadata(username, public_key) if public_key
+          if attributes[:external_ip]
+            if options[:network_interfaces].nil? || options[:network_interfaces].empty?
+              options[:network_interfaces] = [
+                {
+                  :network => "global/networks/#{GOOGLE_COMPUTE_DEFAULT_NETWORK}"
+                }
+              ]
+            end
 
-          options = {
-            "machineType" => machine_type,
-            "networkInterfaces" => network_interfaces,
-            "network" => network,
-            "subnetwork" => subnetwork,
-            "externalIp" => external_ip,
-            "disks" => disks,
-            "metadata" => metadata,
-            "serviceAccounts" => service_accounts,
-            "tags" => tags,
-            "auto_restart" => auto_restart,
-            "on_host_maintenance" => on_host_maintenance,
-            "preemptible" => preemptible,
-            "can_ip_forward" => can_ip_forward
-          }.delete_if { |_key, value| value.nil? }
-
-          if service_accounts
-            options["serviceAccounts"] = [{
-              "kind" => "compute#serviceAccount",
-              "email" => "default",
-              "scopes" => map_service_accounts(service_accounts)
-            }]
+            # Add external IP as default access config if given
+            options[:network_interfaces][0][:access_configs] = [
+              {
+                :name => "External NAT",
+                :type => "ONE_TO_ONE_NAT",
+                :nat_ip => attributes[:external_ip]
+              }
+            ]
           end
 
           data = service.insert_server(name, zone_name, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+
+          operation = Fog::Compute::Google::Operations
+                      .new(:service => service)
+                      .get(data.name, data.zone)
           operation.wait_for { !pending? }
           reload
         end
 
-        private
-
         def generate_ssh_key_metadata(username, key)
-          self.metadata = Hash.new("") if metadata.nil?
-
-          # The key "sshKeys" is deprecated and will be unsupported in the
-          # future - for now defer to using 'ssh-keys' unless the user is
-          # already using the deprecated version
-          # https://cloud.google.com/compute/docs/instances/adding-removing-ssh-keys#deprecated
-          metadata_key = metadata.key?("sshKeys") ? "sshKeys" : "ssh-keys"
+          if metadata.nil?
+            self.metadata = Hash.new
+          end
+          metadata[:items] = [] if metadata[:items].nil?
+          metadata_map = Hash[metadata[:items].map { |item| [item[:key], item[:value]] }]
 
-          # You can have multiple SSH keys, seperated by newlines.
-          # https://developers.google.com/compute/docs/console?hl=en#sshkeys
-          metadata[metadata_key] = "" unless metadata[metadata_key]
-          metadata[metadata_key] += "\n" unless metadata[metadata_key].empty?
-          metadata[metadata_key] += "#{username}:#{key.strip}"
+          ssh_keys = metadata_map["ssh-keys"] || metadata_map["sshKeys"] || ""
+          ssh_keys += "\n" unless ssh_keys.empty?
+          ssh_keys += "#{username}:#{key.strip}"
 
+          metadata_map["ssh-keys"] = ssh_keys
+          metadata[:items] = metadata_to_item_list(metadata_map)
           metadata
         end
+
+        private
+
+        def metadata_to_item_list(metadata)
+          metadata.map { |k, v| { :key => k, :value => v } }
+        end
+
+        def scope_url(scope)
+          if scope.start_with?("https://")
+            scope
+          else
+            "https://www.googleapis.com/auth/#{scope}"
+          end
+        end
       end
     end
   end