fog-google 0.6.0 → 1.0.0

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

@@ -4,13 +4,23 @@ module Fog
       class Servers < Fog::Collection
         model Fog::Compute::Google::Server
 
-        def all(filters = {})
-          if filters["zone"]
-            data = service.list_servers(filters["zone"]).body["items"] || []
+        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_servers(zone, opts).to_h[:items] || []
           else
             data = []
-            service.list_aggregated_servers.body["items"].each_value do |zone|
-              data.concat(zone["instances"]) if zone["instances"]
+            service.list_aggregated_servers(opts).items.each_value do |scoped_lst|
+              if scoped_lst && scoped_lst.instances
+                data.concat(scoped_lst.instances.map(&:to_h))
+              end
             end
           end
           load(data)
@@ -19,58 +29,81 @@ module Fog
         def get(identity, zone = nil)
           response = nil
           if zone
-            response = service.get_server(identity, zone).body
+            response = service.get_server(identity, zone).to_h
           else
-            servers = service.list_aggregated_servers(:filter => "name eq .*#{identity}").body["items"]
-            server = servers.each_value.select { |zone| zone.key?("instances") }
-
-            # It can only be 1 server with the same name across all regions
-            response = server.first["instances"].first unless server.empty?
+            server = all(:filter => "name eq .*#{identity}").first
+            response = server.attributes if server
           end
           return nil if response.nil?
           new(response)
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
 
-        def bootstrap(new_attributes = {})
+        def bootstrap(public_key_path: nil, **opts)
+          user = ENV["USER"]
+          public_key = get_public_key(public_key_path)
+
           name = "fog-#{Time.now.to_i}"
-          zone = "us-central1-f"
+          zone_name = "us-central1-f"
 
-          disks = new_attributes[:disks]
+          disks = opts[:disks]
 
           if disks.nil? || disks.empty?
             # create the persistent boot disk
+            source_img = service.images.get_from_family("debian-8")
             disk_defaults = {
               :name => name,
               :size_gb => 10,
-              :zone_name => zone,
-              :source_image => "debian-8-jessie-v20161215"
+              :zone_name => zone_name,
+              :source_image => source_img.self_link
             }
-
-            # backwards compatibility to pre-v1
-            new_attributes[:source_image] = new_attributes[:image_name] if new_attributes[:image_name]
-
-            disk = service.disks.create(disk_defaults.merge(new_attributes))
+            disk = service.disks.create(disk_defaults.merge(opts))
             disk.wait_for { disk.ready? }
+
             disks = [disk]
           end
 
-          defaults = {
+          data = opts.merge(
             :name => name,
-            :disks => disks,
-            :machine_type => "n1-standard-1",
-            :zone_name => zone,
-            :private_key_path => File.expand_path("~/.ssh/id_rsa"),
-            :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
-            :username => ENV["USER"]
-          }
-
-          server = create(defaults.merge(new_attributes))
-          server.wait_for { sshable? }
+            :zone => zone_name,
+            :disks => disks
+          )
+          data[:machine_type] = "n1-standard-1" unless data[:machine_type]
 
+          server = new(data)
+          server.save(:username => user, :public_key => public_key)
+          # TODO: sshable? was removed, needs to be fixed for tests
+          # server.wait_for { sshable? }
           server
         end
+
+        private
+
+        # Defaults to:
+        # 1. ~/.ssh/google_compute_engine.pub
+        # 2. ~/.ssh/id_rsa.pub
+        PUBLIC_KEY_DEFAULTS = %w(
+          ~/.ssh/google_compute_engine.pub
+          ~/.ssh/id_rsa.pub
+        ).freeze
+        def get_public_key(public_key_path)
+          unless public_key_path
+            PUBLIC_KEY_DEFAULTS.each do |path|
+              if File.exist?(File.expand_path(path))
+                public_key_path = path
+                break
+              end
+            end
+          end
+
+          if public_key_path.nil? || public_key_path.empty?
+            raise ArgumentError("cannot bootstrap instance without public key file")
+          end
+
+          File.read(File.expand_path(public_key_path))
+        end
       end
     end
   end

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

@@ -4,33 +4,45 @@ module Fog
       class Snapshot < Fog::Model
         identity :name
 
-        attribute :kind
-        attribute :self_link, :aliases => "selfLink"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
+        attribute :description
         attribute :disk_size_gb, :aliases => "diskSizeGb"
+        attribute :id
+        attribute :kind
+        attribute :label_fingerprint, :aliases => "labelFingerprint"
+        attribute :labels
+        attribute :licenses
+        attribute :self_link, :aliases => "selfLink"
+        attribute :snapshot_encryption_key, :aliases => "snapshotEncryptionKey"
         attribute :source_disk, :aliases => "sourceDisk"
+        attribute :source_disk_encryption_key, :aliases => "sourceDiskEncryptionKey"
         attribute :source_disk_id, :aliases => "sourceDiskId"
-        attribute :description
         attribute :status
-        attribute :id
         attribute :storage_bytes, :aliases => "storageBytes"
         attribute :storage_bytes_status, :aliases => "storageBytesStatus"
 
-        CREATING_STATE  = "CREATING"
-        DELETING_STATE  = "DELETING"
-        FAILED_STATE    = "FAILED"
-        READY_STATE     = "READY"
-        UPLOADING_STATE = "UPLOADING"
+        CREATING_STATE  = "CREATING".freeze
+        DELETING_STATE  = "DELETING".freeze
+        FAILED_STATE    = "FAILED".freeze
+        READY_STATE     = "READY".freeze
+        UPLOADING_STATE = "UPLOADING".freeze
 
         def destroy(async = true)
           requires :identity
 
           data = service.delete_snapshot(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
 
+        def set_labels(new_labels)
+          requires :identity, :label_fingerprint
+          service.set_snapshot_labels(identity, label_fingerprint, new_labels)
+          reload
+        end
+
         def ready?
           status == READY_STATE
         end

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

@@ -8,9 +8,10 @@ module Fog
           items = []
           next_page_token = nil
           loop do
-            data = service.list_snapshots(nil, next_page_token)
-            items.concat(data.body["items"]) unless data.body["items"].nil?
-            next_page_token = data.body["nextPageToken"]
+            data = service.list_snapshots(:page_token => next_page_token)
+            next_items = data.to_h[:items] || []
+            items.concat(next_items)
+            next_page_token = data.next_page_token
             break if next_page_token.nil? || next_page_token.empty?
           end
           load(items)
@@ -19,8 +20,9 @@ module Fog
         def get(snap_id)
           response = service.get_snapshot(snap_id)
           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/ssl_certificate.rb

@@ -7,6 +7,8 @@ module Fog
       # @see https://cloud.google.com/compute/docs/reference/latest/sslCertificates
       class SslCertificate < Fog::Model
         identity :name
+
+        attribute :kind
         attribute :id
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description
@@ -16,8 +18,12 @@ module Fog
 
         def save
           requires :identity, :certificate, :private_key
-          data = service.insert_ssl_certificate(identity, certificate, private_key, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil)
+          data = service.insert_ssl_certificate(
+            identity, certificate, private_key,
+            :description => description
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
@@ -25,7 +31,8 @@ module Fog
         def destroy(async = true)
           requires :identity
           data = service.delete_ssl_certificate(identity)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil)
+          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/ssl_certificates.rb

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::SslCertificate
 
         def get(certificate_name)
-          if certificate = service.get_ssl_certificate(certificate_name).body
-            new(certificate)
+          if certificate = service.get_ssl_certificate(certificate_name)
+            new(certificate.to_h)
           end
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           nil
         end
 
         def all(_filters = {})
-          data = service.list_ssl_certificates.body["items"] || []
+          data = service.list_ssl_certificates.to_h[:items] || []
           load(data)
         end
       end

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

@@ -15,14 +15,17 @@ module Fog
         attribute :ip_cidr_range, :aliases => "ipCidrRange"
         attribute :kind
         attribute :network
+        attribute :private_ip_google_access, :aliases => "privateIpGoogleAccess"
         attribute :region
+        attribute :secondary_ip_ranges, :aliases => "secondaryIpRanges"
         attribute :self_link, :aliases => "selfLink"
 
         def save
           requires :identity, :network, :region, :ip_cidr_range
 
           data = service.insert_subnetwork(identity, region, network, ip_cidr_range, attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
           operation.wait_for { !pending? }
           reload
         end
@@ -31,7 +34,8 @@ module Fog
           requires :identity, :region
 
           data = service.delete_subnetwork(identity, region)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
           operation.wait_for { ready? } unless async
           operation
         end
@@ -41,6 +45,31 @@ module Fog
           network_interface
         end
 
+        def expand_ip_cidr_range(range, async = true)
+          requires :identity, :region
+
+          data = service.expand_subnetwork_ip_cidr_range(
+            identity, region, range
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
+        def set_private_ip_google_access(access, async = true)
+          requires :identity, :region
+
+          data = service.set_subnetwork_private_ip_google_access(
+            identity, region, access
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name, nil, data.region)
+
+          operation.wait_for { ready? } unless async
+          reload
+        end
+
         def reload
           requires :identity, :region
 

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

@@ -4,23 +4,31 @@ module Fog
       class Subnetworks < Fog::Collection
         model Fog::Compute::Google::Subnetwork
 
-        def all(filters = {})
-          if filters[:region]
-            data = service.list_subnetworks(filters[:region]).body["items"] || []
-          else
+        def all(region: nil, filter: nil, max_results: nil, order_by: nil, page_token: nil)
+          filters = {
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          }
+
+          if region.nil?
             data = []
-            service.list_aggregated_subnetworks(filters).body["items"].each_value do |region|
-              data.concat(region["subnetworks"]) if region["subnetworks"]
+            service.list_aggregated_subnetworks(filters).to_h[:items].each_value do |region_obj|
+              data.concat(region_obj["subnetworks"]) if region_obj["subnetworks"]
             end
+          else
+            data = service.list_subnetworks(region, filters).to_h[:items]
           end
           load(data || [])
         end
 
         def get(identity, region)
-          if subnetwork = service.get_subnetwork(identity, region).body
+          if subnetwork = service.get_subnetwork(identity, region).to_h
             new(subnetwork)
           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/target_http_proxies.rb

@@ -5,15 +5,16 @@ module Fog
         model Fog::Compute::Google::TargetHttpProxy
 
         def all(_filters = {})
-          data = service.list_target_http_proxies.body["items"] || []
+          data = service.list_target_http_proxies.to_h[:items] || []
           load(data)
         end
 
         def get(identity)
-          if target_http_proxy = service.get_target_http_proxy(identity).body
+          if target_http_proxy = service.get_target_http_proxy(identity).to_h
             new(target_http_proxy)
           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/target_http_proxy.rb

@@ -4,57 +4,59 @@ module Fog
       class TargetHttpProxy < Fog::Model
         identity :name
 
-        attribute :kind, :aliases => "kind"
-        attribute :self_link, :aliases => "selfLink"
-        attribute :id, :aliases => "id"
         attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description, :aliases => "description"
+        attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
+        attribute :self_link, :aliases => "selfLink"
         attribute :url_map, :aliases => "urlMap"
 
         def save
-          requires :name
-
-          options = {
-            "description" => description,
-            "urlMap" => url_map
-          }
-
-          data = service.insert_target_http_proxy(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"], data["zone"])
+          requires :identity
+          data = service.insert_target_http_proxy(
+            identity, :description => description, :url_map => url_map
+          )
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
           operation.wait_for { !pending? }
           reload
         end
 
         def destroy(async = true)
-          requires :name
-          operation = service.delete_target_http_proxy(name)
-          unless async
-            # wait until "DONE" to ensure the operation doesn't fail, raises
-            # exception on error
-            Fog.wait_for do
-              operation.body["status"] == "DONE"
-            end
-          end
+          requires :identity
+
+          data = service.delete_target_http_proxy(identity)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           operation
         end
 
-        def set_url_map(url_map)
-          service.set_target_http_proxy_url_map(self, url_map)
+        def set_url_map(url_map, async = true)
+          requires :identity
+
+          data = service.set_target_http_proxy_url_map(identity, url_map)
+          operation = Fog::Compute::Google::Operations.new(:service => service)
+                                                      .get(data.name)
+          operation.wait_for { ready? } unless async
           reload
         end
 
         def ready?
-          service.get_target_http_proxy(name)
+          requires :identity
+
+          service.get_target_http_proxy(identity)
           true
-        rescue Fog::Errors::NotFound
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
           false
         end
 
         def reload
-          requires :name
+          requires :identity
 
           return unless data = begin
-            collection.get(name)
+            collection.get(identity)
           rescue Excon::Errors::SocketError
             nil
           end