fog 1.12.1 → 1.13.0

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

@@ -0,0 +1,80 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      class Disk < Fog::Model
+
+        identity :name
+
+        attribute :kind, :aliases => 'kind'
+        attribute :id, :aliases => 'id'
+        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :zone_name, :aliases => 'zone'
+        attribute :status, :aliases => 'status'
+        attribute :description, :aliases => 'description'
+        attribute :size_gb, :aliases => 'sizeGb'
+        attribute :self_link, :aliases => 'selfLink'
+        attribute :image_name, :aliases => 'image'
+
+        def save
+          data = service.insert_disk(name, size_gb, zone_name, image_name).body
+          data = service.backoff_if_unfound {service.get_disk(name, zone_name).body}
+          service.disks.merge_attributes(data)
+        end
+
+        def destroy
+          requires :name, :zone
+          service.delete_disk(name, zone)
+        end
+
+        def zone
+          if self.zone_name.is_a? String
+            service.get_zone(self.zone_name.split('/')[-1]).body["name"]
+          elsif zone_name.is_a? Excon::Response
+            service.get_zone(zone_name.body["name"]).body["name"]
+          else
+            self.zone_name
+          end
+        end
+
+        def get_as_boot_disk(writable=true)
+          mode = writable ? 'READ_WRITE' : 'READ_ONLY'
+          return {
+              'name' => name,
+              'type' => 'PERSISTENT',
+              'boot' => true,
+              'source' => self_link,
+              'mode' => mode
+          }
+        end
+
+        def ready?
+          data = service.get_disk(self.name, self.zone_name).body
+          data['zone_name'] = self.zone_name
+          self.merge_attributes(data)
+          self.status == RUNNING_STATE
+        end
+
+        def reload
+          requires :identity
+          requires :zone_name
+
+          return unless data = begin
+            collection.get(identity, zone_name)
+          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/disks.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/disk'
+
+module Fog
+  module Compute
+    class Google
+
+      class Disks < Fog::Collection
+
+        model Fog::Compute::Google::Disk
+
+        def all(zone)
+          data = service.list_disks(zone).body["items"]
+          load(data)
+        end
+
+        def get(identity, zone)
+          data = service.get_disk(identity, zone).body
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -12,6 +12,42 @@ module Fog
         attribute :creation_timestamp, :aliases => 'creationTimestamp'
         attribute :description
         attribute :preferred_kernel, :aliases => 'preferredKernel'
+        attribute :project
+
+        def reload
+          requires :name
+
+          data = {}
+
+          # Try looking for the image in known projects
+          [
+            self.service.project,
+            'google',
+            'debian-cloud',
+            'centos-cloud',
+          ].each do |owner|
+            begin
+              data = service.get_image(name, owner).body
+              data[:project] = owner
+            rescue
+            end
+          end
+
+          raise ArgumentError, 'Specified image was not found' if data.empty?
+
+          self.merge_attributes(data)
+          self
+        end
+
+        def save
+          requires :name
+
+          reload
+        end
+
+        def resource_url
+          "#{self.project}/global/images/#{name}"
+        end
 
       end
     end

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

@@ -13,11 +13,13 @@ module Fog
         attribute :state, :aliases => 'status'
         attribute :zone_name, :aliases => 'zone'
         attribute :machine_type, :aliases => 'machineType'
+        attribute :disks, :aliases => 'disks'
+        attribute :kernel, :aliases => 'kernel'
         attribute :metadata
 
         def destroy
-          requires :name
-          service.delete_server(name)
+          requires :name, :zone
+          service.delete_server(name, zone)
         end
 
         def image
@@ -25,53 +27,64 @@ module Fog
         end
 
         def public_ip_address
-          if self.network_interfaces.count
-            self.network_interfaces[0]["networkIP"]
-          else
-            nil
+          ip = nil
+          if self.network_interfaces
+            self.network_interfaces.each do |netif|
+              netif["accessConfigs"].each do |access_config|
+                if access_config["name"] == "External NAT"
+                  ip = access_config['natIP']
+                end
+              end
+            end
           end
+
+          ip
         end
 
         def ready?
-          data = service.get_server(self.name, self.zone_name).body
-          data['zone_name'] = self.zone_name
-          self.merge_attributes(data)
-          self.state == RUNNING_STATE
+          self.state == RUNNING
         end
 
         def zone
-          service.get_zone(self.zone_name.split('/')[-1])
+          if self.zone_name.is_a? String
+            service.get_zone(self.zone_name.split('/')[-1]).body["name"]
+          elsif zone_name.is_a? Excon::Response
+            service.get_zone(zone_name.body["name"]).body["name"]
+          else
+            self.zone_name
+          end
+        end
+
+        def reload
+          data = service.get_server(self.name, self.zone).body
+          self.merge_attributes(data)
         end
 
         def save
           requires :name
-          requires :image_name
           requires :machine_type
           requires :zone_name
 
-          data = service.insert_server(
-            name,
-            image_name,
-            zone_name,
-            machine_type)
-
-          data = service.get_server(self.name, self.zone_name).body
-          service.servers.merge_attributes(data)
-        end
+          if self.metadata.nil?
+            self.metadata = {}
+          end
 
-        def setup(credentials = {})
-          requires :public_ip_address, :public_key, :username
-          service.set_metadata(self.instance, self.zone, {'sshKeys' => self.public_key })
-        rescue Errno::ECONNREFUSED
-          sleep(1)
-          retry
-        end
+          self.metadata.merge!({
+            "sshKeys" => "#{username}:#{File.read(public_key_path).strip}"
+          }) if public_key_path
 
-        def sshable?(options={})
-          service.set_metadata(self.instance, self.zone, {'sshKeys' => self.public_key })
-          ready? && !public_ip_address.nil? && public_key && metadata['sshKeys']
-        rescue SystemCallError, Net::SSH::AuthenticationFailed, Timeout::Error
-          false
+          options = {
+              'image' => image_name,
+              'machineType' => machine_type,
+              'networkInterfaces' => network_interfaces,
+              'disks' => disks,
+              'kernel' => kernel,
+              'metadata' => metadata
+          }
+          options.delete_if {|key, value| value.nil?}
+          service.insert_server(name, zone_name, options)
+          data = service.backoff_if_unfound {service.get_server(self.name, self.zone_name).body}
+          service.servers.merge_attributes(data)
         end
 
       end

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

@@ -22,20 +22,20 @@ module Fog
         end
 
         def get(identity, zone=nil)
-          data = nil
+          response = nil
           if zone.nil?
             service.list_zones.body['items'].each do |zone|
-              data = service.get_server(identity, zone['name']).body
-              break if data["code"] == 200
+              response = service.get_server(identity, zone['name'])
+              break if response.status == 200
             end
           else
-            data = service.get_server(identity, zone).body
+            response = service.get_server(identity, zone)
           end
 
-          if data["code"] != 200
+          if response.nil? or response.status != 200
             nil
           else
-            new(data)
+            new(response.body)
           end
         rescue Excon::Errors::NotFound
           nil
@@ -44,15 +44,22 @@ module Fog
         def bootstrap(new_attributes = {})
           defaults = {
             :name => "fog-#{Time.now.to_i}",
-            :image_name => "gcel-12-04-v20130225",
+            :image_name => "debian-7-wheezy-v20130617",
             :machine_type => "n1-standard-1",
             :zone_name => "us-central1-a",
             :private_key_path => File.expand_path("~/.ssh/id_rsa"),
             :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
+            :username => ENV['USER'],
           }
+          if new_attributes[:disks]
+            new_attributes[:disks].each do |disk|
+              defaults.delete :image_name if disk['boot']
+            end
+          end
 
           server = create(defaults.merge(new_attributes))
-          server.wait_for(Fog.timeout, 30) { ready? }
+          server.wait_for { sshable? }
+
           server
         end
       end

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

@@ -15,11 +15,14 @@ module Fog
         def delete_server(server_name, zone_name=nil)
           if zone_name.nil?
             list_zones.body['items'].each do |zone|
-              data = get_server(server_name, zone['name']).body
-              if data["error"].nil?
+              if get_server(server_name, zone['name']).status == 200
                 zone_name = zone['name']
               end
             end
+          else
+            if zone_name.is_a? Excon::Response
+              zone_name = zone_name.body["name"]
+            end
           end
 
           api_method = @compute.instances.delete

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

@@ -13,6 +13,9 @@ module Fog
       class Real
 
         def get_disk(disk_name, zone_name=@default_zone)
+          if zone_name.start_with? 'http'
+            zone_name = zone_name.split('/')[-1]
+          end
           api_method = @compute.disks.get
           parameters = {
             'project' => @project,

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

@@ -13,10 +13,16 @@ module Fog
       class Real
 
         def get_server(server_name, zone_name)
+          if zone_name.is_a? Excon::Response
+            zone = zone_name.body["name"]
+          else
+            zone = zone_name
+          end
+
           api_method = @compute.instances.get
           parameters = {
             'project' => @project,
-            'zone' => zone_name,
+            'zone' => zone,
             'instance' => server_name
           }
 

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

@@ -12,19 +12,25 @@ module Fog
 
       class Real
 
-        def insert_disk(disk_name, disk_size, zone_name=@default_zone)
+        def insert_disk(disk_name, disk_size, zone_name=@default_zone, image_name=nil)
           api_method = @compute.disks.insert
           parameters = {
             'project' => @project,
             'zone' => zone_name
           }
+          if image_name
+            # We don't know the owner of the image.
+            image = images.create({:name => image_name})
+            @image_url = @api_url + image.resource_url
+            parameters['sourceImage'] = @image_url
+          end
           body_object = {
             'name' => disk_name,
             'sizeGb' => disk_size,
           }
 
           result = self.build_result(api_method, parameters,
-                                     body_object=body_object)
+                                     body_object)
           response = self.build_response(result)
         end
 

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

@@ -12,38 +12,67 @@ module Fog
 
       class Real
 
-        def insert_server(server_name, image_name,
-                          zone_name, machine_name,
-                          network_name=@default_network)
-
-          # We need to check if the image is owned by the user or a global image.
-          if get_image(image_name, @project).data['code'] == 200
-            image_url = @api_url + @project + "/global/images/#{image_name}"
-          else
-            image_url = @api_url + "google/global/images/#{image_name}"
-          end
+        def format_metadata(metadata)
+          { "items" => metadata.map {|k,v| {"key" => k, "value" => v}} }
+        end
 
+        def insert_server(server_name, zone_name, options={}, *deprecated_args)
+          if deprecated_args.length > 0 or not options.is_a? Hash
+            raise ArgumentError.new 'Too many parameters specified. This may be the cause of code written for an outdated'\
+                ' version of fog. Usage: server_name, zone_name, [options]'
+          end
           api_method = @compute.instances.insert
           parameters = {
-            'project' => @project,
-            'zone' => zone_name,
-          }
-          body_object = {
-            'name' => server_name,
-            'image' => image_url,
-            'machineType' => @api_url + @project + "/global/machineTypes/#{machine_name}",
-            'networkInterfaces' => [{
-              'network' => @api_url + @project + "/global/networks/#{network_name}"
-            }]
+              'project' => @project,
+              'zone' => zone_name,
           }
+          body_object = {:name => server_name}
+
+          if options.has_key? 'image'
+            image_name = options.delete 'image'
+            # We don't know the owner of the image.
+            image = images.create({:name => image_name})
+            @image_url = @api_url + image.resource_url
+            body_object['image'] = @image_url
+          end
+          body_object['machineType'] = @api_url + @project + "/zones/#{zone_name}/machineTypes/#{options.delete 'machineType'}"
+          networkInterfaces = []
+          if @default_network
+            networkInterfaces << {
+                'network' => @api_url + @project + "/global/networks/#{@default_network}",
+                'accessConfigs' => [
+                    {'type' => 'ONE_TO_ONE_NAT',
+                     'name' => 'External NAT'}
+                ]
+            }
+          end
+          # TODO: add other networks
+          body_object['networkInterfaces'] = networkInterfaces
+
+          if options['disks']
+            disks = []
+            options.delete('disks').each do |disk|
+              if disk.is_a? Disk
+                disks << disk.get_object
+              else
+                disks << disk
+              end
+            end
+            body_object['disks'] = disks
+          end
+
+          options['metadata'] = format_metadata options['metadata'] if options['metadata']
+
+          if options['kernel']
+            body_object['kernel'] = @api_url + "google/global/kernels/#{options.delete 'kernel'}"
+          end
+          body_object.merge! options # Adds in all remaining options that weren't explicitly handled.
 
           result = self.build_result(api_method, parameters,
                                      body_object=body_object)
           response = self.build_response(result)
         end
-
       end
-
     end
   end
 end