fog-google 0.0.2

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

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/operation'
+
+module Fog
+  module Compute
+    class Google
+      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
+          else
+            data = service.list_global_operations.body
+          end
+          load(data['items'] || [])
+        end
+
+        def get(identity, zone=nil, region=nil)
+          if not zone.nil?
+            response = service.get_zone_operation(zone, identity)
+          elsif not region.nil?
+            response = service.get_region_operation(region, identity)
+          else
+            response = service.get_global_operation(identity)
+          end
+          return nil if response.nil?
+          new(response.body)
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Project resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/projects
+      class Project < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :common_instance_metadata, :aliases => 'commonInstanceMetadata'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :quotas
+        attribute :self_link, :aliases => 'selfLink'
+
+        def set_metadata(metadata = {})
+          requires :identity
+
+          data = service.set_common_instance_metadata(identity, self.common_instance_metadata['fingerprint'], metadata)
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/project'
+
+module Fog
+  module Compute
+    class Google
+      class Projects < Fog::Collection
+        model Fog::Compute::Google::Project
+
+        def get(identity)
+          if project = service.get_project(identity).body
+            new(project)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Region resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/regions
+      class Region < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :deprecated
+        attribute :description
+        attribute :quotas
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :status
+        attribute :zones
+
+        DOWN_STATE = 'DOWN'
+        UP_STATE   = 'UP'
+
+        def up?
+          self.status == UP_STATE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/region'
+
+module Fog
+  module Compute
+    class Google
+      class Regions < Fog::Collection
+        model Fog::Compute::Google::Region
+
+        def all
+          data = service.list_regions.body
+          load(data['items'] || [])
+        end
+
+        def get(identity)
+          if region = service.get_region(identity).body
+            new(region)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'fog/core/model'
+# the resource view model creates either a region view or zone view depending on which is parameter is passed
+
+module Fog
+  module Compute
+    class Google
+      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 then
+            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 then
+            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.self_link.split('/')
+          if selflink[7]=='regions' then
+            operation = service.delete_region_view(name, selflink[8])
+          end
+        
+          if selflink[7]== 'zones' then
+            operation= service.delete_zone_view(name, selflink[8])
+          end
+
+          if not 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 } 
+          if @zone then
+            service.add_zone_view_resources(self, resources, @zone)
+          end
+          if @region then
+            service.add_region_view_resources(self, reources, @region)
+          end
+          reload
+        end
+
+        def ready?
+          begin
+            if @zone then service.get_zone_view(self.name, @zone) end
+            if @region then service.get_region_view(self.name, @region) end
+            true
+          rescue Fog::Errors::NotFound
+            false
+          end
+        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/google/models/compute/resource_views.rb

@@ -0,0 +1,57 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/resource_view'
+
+module Fog
+  module Compute
+    class Google
+      class ResourceViews < Fog::Collection
+        model Fog::Compute::Google::ResourceView
+
+        def all(filters={})
+          if fliters['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(fliters['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/route.rb

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+      ##
+      # Represents a Route resource
+      #
+      # @see https://developers.google.com/compute/docs/reference/latest/routes
+      class Route < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        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 :priority
+        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'])
+          operation.wait_for { !pending? }
+          reload
+        end
+
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/route'
+
+module Fog
+  module Compute
+    class Google
+      class Routes < Fog::Collection
+        model Fog::Compute::Google::Route
+
+        def all
+          data = service.list_routes.body
+          load(data['items'] || [])
+        end
+
+        def get(identity)
+          if route = service.get_route(identity).body
+            new(route)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+require 'fog/compute/models/server'
+require 'net/ssh/proxy/command'
+
+module Fog
+  module Compute
+    class Google
+      class Server < Fog::Compute::Server
+        identity :name
+
+        attribute :kind
+        attribute :id
+        attribute :can_ip_forward, :aliases => 'canIpForward'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :description
+        attribute :disks
+        attribute :machine_type, :aliases => 'machineType'
+        attribute :metadata
+        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 :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 :auto_restart
+        attribute :on_host_maintenance
+
+        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']
+            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)
+          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'])
+          unless async
+            operation.wait_for { ready? }
+          end
+          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])
+        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
+                end
+              end
+            end
+          end
+
+          ip
+        end
+
+        def private_ip_address
+          ip = nil
+          if self.network_interfaces.respond_to? :first
+            ip = self.network_interfaces.first['networkIP']
+          end
+          ip
+        end
+
+        def addresses
+          [private_ip_address, public_ip_address]
+        end
+
+        def attach_disk(disk, 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'])
+        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'])
+        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'])
+        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'])
+        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'])
+        end
+
+        def serial_port_output
+          requires :identity, :zone
+
+          data = service.get_server_serial_port_output(identity, zone_name)
+          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'])
+        end
+
+        def set_scheduling(on_host_maintenance, automatic_restart)
+          requires :identity, :zone
+
+          data = service.set_server_scheduling(identity, zone_name, on_host_maintenance, automatic_restart)
+          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'])
+        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'])
+        end
+
+        def ready?
+          self.state == RUNNING
+        end
+
+        def zone_name
+          zone.nil? ? nil : zone.split('/')[-1]
+        end
+
+        def add_ssh_key username, key
+          if self.metadata.nil?
+            self.metadata = Hash.new("")
+          end
+
+          # 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
+
+          if !self.metadata["sshKeys"].empty?
+            self.metadata["sshKeys"] += "\n"
+          end
+
+          self.metadata["sshKeys"] += "#{username}:#{key.strip}"
+
+          return self.metadata
+        end
+
+        def reload
+          data = service.get_server(self.name, zone_name).body
+          self.merge_attributes(data)
+        end
+
+        def save
+          requires :name
+          requires :machine_type
+          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."
+          end
+
+          self.add_ssh_key(self.username, self.public_key) if self.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,
+              'can_ip_forward' => can_ip_forward
+          }.delete_if {|key, value| value.nil?}
+
+          if service_accounts
+            options['serviceAccounts'] = [{
+              "kind" => "compute#serviceAccount",
+              "email" => "default",
+              "scopes" => service_accounts.map {
+                |w| w.start_with?("https://") ? w : "https://www.googleapis.com/auth/#{w}"
+              }
+            }]
+          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.wait_for { !pending? }
+          reload
+        end
+      end
+    end
+  end
+end