fog-google 0.1.3 → 0.2.0

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

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/project'
-
 module Fog
   module Compute
     class Google

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

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -12,19 +10,19 @@ module Fog
 
         attribute :kind
         attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :deprecated
         attribute :description
         attribute :quotas
-        attribute :self_link, :aliases => 'selfLink'
+        attribute :self_link, :aliases => "selfLink"
         attribute :status
         attribute :zones
 
-        DOWN_STATE = 'DOWN'
-        UP_STATE   = 'UP'
+        DOWN_STATE = "DOWN"
+        UP_STATE   = "UP"
 
         def up?
-          self.status == UP_STATE
+          status == UP_STATE
         end
       end
     end

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

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/region'
-
 module Fog
   module Compute
     class Google
@@ -9,7 +6,7 @@ module Fog
 
         def all
           data = service.list_regions.body
-          load(data['items'] || [])
+          load(data["items"] || [])
         end
 
         def get(identity)

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

@@ -0,0 +1,108 @@
+module Fog
+  module Compute
+    class Google
+      # the resource view model creates either a region view or zone view depending on which is parameter is passed
+      class ResourceView < 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 :region, :aliases => "region" # string, required for region views
+        attribute :labels, :aliases => "labels" # array of hashes including 'key' and 'value' as keys
+        attribute :zone, :aliases => "zone" # string, required for zone views
+        attribute :last_modified, :aliases => "lastModified"
+        attribute :members, :aliases => "members" # array of members of resource view
+        attribute :num_members, :aliases => "numMemebers" # integer
+
+        def save
+          requires :name
+          labels ||= []
+          members ||= []
+
+          if region
+            options = {
+              "description" => description,
+              "labels" => labels,
+              "lastModified" => last_modified,
+              "members" => members,
+              "numMembers" => num_members
+            }
+            @region = region
+            data = service.insert_region_view(name, region, options).body
+            operation = service.get_region_view(data["resource"]["name"], nil, @region).body
+          end
+
+          if zone
+            options = {
+              "description" => description,
+              "labels" => labels,
+              "lastModified" => last_modified,
+              "members" => members,
+              "numMembers" => num_members
+            }
+            @zone = zone
+            data = service.insert_zone_view(name, zone, options).body
+            operation = service.get_zone_view(data["resource"]["name"], @zone).body
+          end
+          reload
+        end
+
+        def destroy(async = false)
+          requires :name
+          # parse the self link to get the zone or region
+          selflink = self_link.split("/")
+          if selflink[7] == "regions"
+            operation = service.delete_region_view(name, selflink[8])
+          end
+
+          if selflink[7] == "zones"
+            operation = service.delete_zone_view(name, selflink[8])
+          end
+
+          unless async
+            # wait until "DONE" to ensure the operation doesn't fail, raises
+            # exception on error
+            Fog.wait_for do
+              operation.body.nil?
+            end
+          end
+          operation
+        end
+
+        def add_resources(resources)
+          resources = [resources] unless resources.class == Array
+          resources.map { |resource| resource.class == String ? resource : resource.self_link }
+          service.add_zone_view_resources(self, resources, @zone) if @zone
+          service.add_region_view_resources(self, reources, @region) if @region
+          reload
+        end
+
+        def ready?
+          service.get_zone_view(name, @zone) if @zone
+          service.get_region_view(name, @region) if @region
+          true
+        rescue Fog::Errors::NotFound
+          false
+        end
+
+        def reload
+          requires :name
+
+          return unless data = begin
+            collection.get(name, region, zone)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+        RUNNING_STATE = "READY"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class Google
+      class ResourceViews < Fog::Collection
+        model Fog::Compute::Google::ResourceView
+
+        def all(filters = {})
+          if filters["region"].nil? && filters["zone"].nil?
+            data = []
+            service.list_regions.body["items"].each do |region|
+              data += service.list_region_views(region["name"]).body["items"] || []
+            end
+            service.list_zones.body["items"].each do |zone|
+              data += service.list_zone_views(zone["name"]).body["items"] || []
+            end
+          elsif filters["zone"]
+            data = service.list_zone_views(filters["zone"]).body["items"] || []
+          else
+            data = service.list_region_views(filters["region"]).body["items"] || []
+          end
+          load(data)
+        end
+
+        def get(identity, region = nil, zone = nil)
+          response = nil
+
+          if region.nil? & zone.nil?
+            service.list_regions.body["items"].each do |region|
+              begin
+                response = service.get_region_view(identity, region["name"])
+                break if response.status == 200
+              rescue Fog::Errors::Error
+              end
+            end
+            service.list_zones.body["items"].each do |zone|
+              begin
+                response = service.get_zone_view(identity, zone["name"])
+                break if response.status == 200
+              rescue Fog::Errors::Error
+              end
+            end
+          elsif region
+            response = service.get_region_view(identity, region)
+          else
+            response = service.get_zone_view(identity, zone)
+          end
+
+          return nil if response.nil?
+          new(response.body)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -12,36 +10,34 @@ module Fog
 
         attribute :kind
         attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description
-        attribute :dest_range, :aliases => 'destRange'
+        attribute :dest_range, :aliases => "destRange"
         attribute :network
-        attribute :next_hop_gateway, :aliases => 'nextHopGateway'
-        attribute :next_hop_instance, :aliases => 'nextHopInstance'
-        attribute :next_hop_ip, :aliases => 'nextHopIp'
-        attribute :next_hop_network, :aliases => 'nextHopNetwork'
+        attribute :next_hop_gateway, :aliases => "nextHopGateway"
+        attribute :next_hop_instance, :aliases => "nextHopInstance"
+        attribute :next_hop_ip, :aliases => "nextHopIp"
+        attribute :next_hop_network, :aliases => "nextHopNetwork"
         attribute :priority
-        attribute :self_link, :aliases => 'selfLink'
+        attribute :self_link, :aliases => "selfLink"
         attribute :tags
         attribute :warnings
 
         def save
           requires :identity, :network, :dest_range, :priority
 
-          data = service.insert_route(identity, self.network, self.dest_range, self.priority, self.attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+          data = service.insert_route(identity, network, dest_range, priority, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        def destroy(async = true)
           requires :identity
 
           data = service.delete_route(identity)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
-          unless async
-            operation.wait_for { ready? }
-          end
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation.wait_for { ready? } unless async
           operation
         end
       end

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

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/route'
-
 module Fog
   module Compute
     class Google
@@ -9,7 +6,7 @@ module Fog
 
         def all
           data = service.list_routes.body
-          load(data['items'] || [])
+          load(data["items"] || [])
         end
 
         def get(identity)

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

@@ -1,5 +1,4 @@
-require 'fog/compute/models/server'
-require 'net/ssh/proxy/command'
+require "fog/compute/models/server"
 
 module Fog
   module Compute
@@ -9,25 +8,25 @@ module Fog
 
         attribute :kind
         attribute :id
-        attribute :can_ip_forward, :aliases => 'canIpForward'
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :can_ip_forward, :aliases => "canIpForward"
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description
         attribute :disks
-        attribute :machine_type, :aliases => 'machineType'
+        attribute :machine_type, :aliases => "machineType"
         attribute :metadata
-        attribute :network_interfaces, :aliases => 'networkInterfaces'
+        attribute :network_interfaces, :aliases => "networkInterfaces"
         attribute :scheduling
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :service_accounts, :aliases => 'serviceAccounts'
-        attribute :state, :aliases => 'status'
-        attribute :status_message, :aliases => 'statusMessage'
+        attribute :self_link, :aliases => "selfLink"
+        attribute :service_accounts, :aliases => "serviceAccounts"
+        attribute :state, :aliases => "status"
+        attribute :status_message, :aliases => "statusMessage"
         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 :external_ip, :aliases => 'externalIP'
+        attribute :network, :aliases => "network"
+        attribute :external_ip, :aliases => "externalIP"
         attribute :auto_restart
         attribute :on_host_maintenance
         attribute :preemptible
@@ -35,33 +34,33 @@ module Fog
         # Security account scope aliases used by official gcloud utility
         # List derived from 'gcloud compute instances create --help'
         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)
+          "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
 
         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]
           end
           boot_disk.source_image.nil? ? nil : boot_disk.source_image
         end
 
-        def kernel=(args)
+        def kernel=(_args)
           Fog::Logger.deprecation("kernel= is no longer used [light_black](#{caller.first})[/]")
         end
 
@@ -75,35 +74,32 @@ module Fog
         end
 
         def flavor_id=(flavor_id)
-          machine_type=flavor_id
+          machine_type = flavor_id
         end
 
-        def destroy(async=true)
+        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'])
-          unless async
-            operation.wait_for { ready? }
-          end
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["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(self.image_name.split('/')[-1])
+          service.get_image(image_name.split("/")[-1])
         end
 
         def public_ip_address
           ip = nil
-          if self.network_interfaces.respond_to? :each
-            self.network_interfaces.each do |netif|
-              if netif["accessConfigs"].respond_to? :each
-                netif["accessConfigs"].each do |access_config|
-                  if access_config["name"] == "External NAT"
-                    ip = access_config['natIP']
-                  end
+          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
               end
             end
@@ -114,8 +110,8 @@ module Fog
 
         def private_ip_address
           ip = nil
-          if self.network_interfaces.respond_to? :first
-            ip = self.network_interfaces.first['networkIP']
+          if network_interfaces.respond_to? :first
+            ip = network_interfaces.first["networkIP"]
           end
           ip
         end
@@ -128,102 +124,95 @@ module Fog
           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'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def detach_disk(device_name)
           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'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def reboot
           requires :identity, :zone
 
           data = service.reset_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def start
           requires :identity, :zone
 
           data = service.start_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def stop
           requires :identity, :zone
 
           data = service.stop_server(identity, zone_name)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def serial_port_output
           requires :identity, :zone
 
           data = service.get_server_serial_port_output(identity, zone_name)
-          data.body['contents']
+          data.body["contents"]
         end
 
         def set_disk_auto_delete(auto_delete, device_name)
           requires :identity, :zone
 
           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'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def set_scheduling(on_host_maintenance, automatic_restart, preemptible)
           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'])
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def set_metadata(metadata = {})
           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'])
+          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"])
         end
 
         def set_tags(tags = [])
           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_tags(identity, zone_name, self.tags["fingerprint"], tags)
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def ready?
-          self.state == RUNNING
+          state == RUNNING
         end
 
         def zone_name
-          zone.nil? ? nil : zone.split('/')[-1]
+          zone.nil? ? nil : zone.split("/")[-1]
         end
 
-        def add_ssh_key username, key
-          if self.metadata.nil?
-            self.metadata = Hash.new("")
-          end
+        def add_ssh_key(username, key)
+          self.metadata = Hash.new("") if metadata.nil?
 
           # You can have multiple SSH keys, seperated by newlines.
           # https://developers.google.com/compute/docs/console?hl=en#sshkeys
-          if !self.metadata["sshKeys"]
-            self.metadata["sshKeys"] = ""
-          end
+          metadata["sshKeys"] = "" unless metadata["sshKeys"]
 
-          if !self.metadata["sshKeys"].empty?
-            self.metadata["sshKeys"] += "\n"
-          end
+          metadata["sshKeys"] += "\n" unless metadata["sshKeys"].empty?
 
-          self.metadata["sshKeys"] += "#{username}:#{key.strip}"
+          metadata["sshKeys"] += "#{username}:#{key.strip}"
 
-          return self.metadata
+          metadata
         end
 
         def map_service_accounts(scope_array)
-
           scope_array_expanded = scope_array.map do |e|
             if GCE_SCOPE_ALIASES[e]
               GCE_SCOPE_ALIASES[e]
@@ -240,12 +229,12 @@ module Fog
             end
           end
 
-          return scope_array_finalized
+          scope_array_finalized
         end
 
         def reload
-          data = service.get_server(self.name, zone_name).body
-          self.merge_attributes(data)
+          data = service.get_server(name, zone_name).body
+          merge_attributes(data)
         end
 
         def save
@@ -254,37 +243,37 @@ module Fog
           requires :zone_name
           requires :disks
 
-          if not service.zones.find{ |zone| zone.name == self.zone_name }
-            raise ArgumentError.new "#{self.zone_name.inspect} is either down or you don't have permission to use it."
+          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."
           end
 
-          self.add_ssh_key(self.username, self.public_key) if self.public_key
+          add_ssh_key(username, public_key) if public_key
 
           options = {
-              'machineType' => machine_type,
-              'networkInterfaces' => network_interfaces,
-              'network' => network,
-              '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?}
+            "machineType" => machine_type,
+            "networkInterfaces" => network_interfaces,
+            "network" => network,
+            "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'] = [{
+            options["serviceAccounts"] = [{
               "kind" => "compute#serviceAccount",
               "email" => "default",
-              "scopes" => self.map_service_accounts(service_accounts)
+              "scopes" => map_service_accounts(service_accounts)
             }]
           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.body["name"], data.body["zone"])
           operation.wait_for { !pending? }
           reload
         end