fog 1.19.0 → 1.20.0

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

@@ -16,6 +16,7 @@ module Fog
           :aliases => 'maximumPersistentDisks'
         attribute :maximum_persistent_disks_size,
           :aliases => 'maximumPersistentDisksSizeGb'
+        attribute :self_link, :aliases => 'selfLink'
 
       end
 

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

@@ -18,7 +18,7 @@ module Fog
         def get(identity, zone_name = nil)
           data = connection.get_machine_type(identity, zone_name).body
           new(data)
-        rescue Excon::Errors::NotFound
+        rescue Fog::Errors::NotFound
           nil
         end
 

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

@@ -8,10 +8,11 @@ module Fog
 
         identity :name
 
+        attribute :id
         attribute :kind
+        attribute :self_link, :aliases => 'selfLink'
         attribute :creation_timestamp, :aliases => 'creationTimestamp'
         attribute :description
-        attribute :preferred_kernel, :aliases => 'preferredKernel'
 
         # This attribute is not available in the representation of an
         # 'image' returned by the GCE servser (see GCE API). However,
@@ -30,6 +31,14 @@ module Fog
 
         attribute :status
 
+        def preferred_kernel=(args)
+          Fog::Logger.deprecation("preferred_kernel= is no longer used [light_black](#{caller.first})[/]")
+        end
+        def preferred_kernel
+          Fog::Logger.deprecation("preferred_kernel is no longer used [light_black](#{caller.first})[/]")
+          nil
+        end
+
         def reload
           requires :name
 
@@ -41,11 +50,9 @@ module Fog
 
         def save
           requires :name
-          requires :preferred_kernel
           requires :raw_disk
 
           options = {
-            'preferredKernel' => preferred_kernel,
             'rawDisk'         => raw_disk,
             'description'     => description,
           }

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

@@ -12,6 +12,8 @@ module Fog
         GLOBAL_PROJECTS = [ 'google',
                             'debian-cloud',
                             'centos-cloud',
+                          # RHEL removed from this list because not everyone has access to it.
+                          #  'rhel-cloud', 
                           ]
 
         def all

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

@@ -8,7 +8,7 @@ module Fog
       class Server < Fog::Compute::Server
 
         identity :name
-        attribute :image_name, :aliases => 'image'
+
         attribute :network_interfaces, :aliases => 'networkInterfaces'
         attribute :network, :aliases => 'network'
         attribute :external_ip, :aliases => 'externalIP'
@@ -16,9 +16,31 @@ module Fog
         attribute :zone_name, :aliases => 'zone'
         attribute :machine_type, :aliases => 'machineType'
         attribute :disks, :aliases => 'disks'
-        attribute :kernel, :aliases => 'kernel'
         attribute :metadata
         attribute :tags, :squash => 'items'
+        attribute :self_link, :aliases => 'selfLink'
+
+        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
@@ -39,7 +61,9 @@ module Fog
           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
 
@@ -112,6 +136,7 @@ module Fog
           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."
@@ -120,13 +145,11 @@ module Fog
           self.add_ssh_key(self.username, self.public_key) if self.public_key
 
           options = {
-              'image' => image_name,
               'machineType' => machine_type,
               'networkInterfaces' => network_interfaces,
               'network' => network,
               'externalIp' => external_ip,
               'disks' => disks,
-              'kernel' => kernel,
               'metadata' => metadata,
               'tags' => tags
           }.delete_if {|key, value| value.nil?}

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

@@ -40,27 +40,43 @@ module Fog
           else
             new(response.body)
           end
-        rescue Excon::Errors::NotFound
+        rescue Fog::Errors::NotFound
           nil
         end
 
         def bootstrap(new_attributes = {})
+          name = "fog-#{Time.now.to_i}"
+          zone = "us-central1-b"
+
+          disks = new_attributes[:disks]
+
+          if disks.nil? or disks.empty?
+            # create the persistent boot disk
+            disk_defaults = {
+              :name => name,
+              :size_gb => 10,
+              :zone_name => zone,
+              :source_image => "debian-7-wheezy-v20131120",
+            }
+
+            # 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.wait_for { disk.ready? }
+            disks = [disk]
+          end
+
           defaults = {
-            :name => "fog-#{Time.now.to_i}",
-            :image_name => "debian-7-wheezy-v20131014",
+            :name => name,
+            :disks => disks,
             :machine_type => "n1-standard-1",
-            :zone_name => "us-central1-b",
+            :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'],
           }
 
-          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 { sshable? }
 

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

@@ -14,6 +14,7 @@ module Fog
         attribute :end_time, :aliases => 'endTime'
         attribute :quotas
         attribute :region
+        attribute :self_link, :aliases => 'selfLink'
 
         def up?
           self.status == "UP"

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

@@ -17,7 +17,7 @@ module Fog
         def get(identity)
           data = service.get_zone(identity).body
           new(data)
-        rescue Excon::Errors::NotFound
+        rescue Fog::Errors::NotFound
           nil
         end
 

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+        def attach_disk(instance, zone, deviceName)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+
+        def attach_disk(instance, zone, deviceName)
+          api_method = @compute.instances.attach_disk
+          parameters = {
+            'project' => @project,
+            'instance' => instance,
+            'zone' => zone
+          }
+          body_object = {
+            "deviceName" => deviceName
+          }
+          result = self.build_result(api_method, parameters, body_object=body_object)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def delete_address(address_name, region_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def delete_address(address_name, region_name)
+          api_method = @compute.addresses.delete
+          parameters = {
+            'project' => @project,
+            'address' => address_name,
+            'region' => region_name
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def delete_snapshot(snapshot_name, zone_name)
+          Fog::Mock.not_implemented
+        end  
+
+      end
+
+      class Real
+
+        def delete_snapshot(snapshot_name, zone_name)
+          if zone_name.start_with? 'http'
+            zone_name = zone_name.split('/')[-1]
+          end
+
+          api_method = @compute.snapshots.delete
+          parameters = {
+            'project' => @project,
+            'snapshot' => snapshot_name,
+            'zone' => zone_name,
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+        def detach_disk(instance, zone, deviceName)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+
+        def detach_disk(instance, zone, deviceName)
+          api_method = @compute.instances.detach_disk
+          parameters = {
+            'project' => @project,
+            'instance' => instance,
+            'zone' => zone,
+          }
+          body_object = { "deviceName" => deviceName }
+          result = self.build_result(api_method, parameters, body_object=body_object)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def get_address(address_name, region_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def get_address(address_name, region_name)
+          api_method = @compute.addresses.get
+          parameters = {
+            'project' => @project,
+            'address' => address_name,
+            'region' => region_name
+          }
+
+          result = self.build_result(api_method, parameters)
+          response = self.build_response(result)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Google
+
+      class Mock
+
+        def insert_address(address_name, region_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def insert_address(address_name, region_name)
+          api_method = @compute.addresses.insert
+          parameters = {
+            'project' => @project,
+            'region' => region_name,
+          }
+          body_object = { 'name' => address_name }
+
+          result = self.build_result(api_method, parameters,
+                                     body_object=body_object)
+          response = self.build_response(result)
+        end
+      end
+    end
+  end
+end

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

@@ -6,18 +6,15 @@ module Fog
 
         def insert_disk(disk_name, zone_name, image_name=nil, options={})
           # check that image and zone exist
-          image_project = nil
-          unless image_name.nil?
-            ([ @project ] + Fog::Compute::Google::Images::GLOBAL_PROJECTS).each do |project|
-              image_project = project
-              break if data(project)[:images][options['image']]
-            end
-            get_image(image_name, image_project) # ok if image exists, will fail otherwise
+          image = nil
+          if image_name
+            image = images.get(image_name)
+            raise ArgumentError.new("Invalid image specified: #{image_name}") unless image
           end
           get_zone(zone_name)
 
           id = Fog::Mock.random_numbers(19).to_s
-          self.data[:disks][disk_name] = {
+          object = {
             "kind" => "compute#disk",
             "id" => id,
             "creationTimestamp" => Time.now.iso8601,
@@ -27,22 +24,37 @@ module Fog
             "sizeGb" => options['sizeGb'] || "10",
             "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/disks/#{disk_name}"
           }
+          if image
+            object.merge({
+              "sourceImage" => image.self_link,
+              "sourceImageId" => image.id
+            })
+          end
+          self.data[:disks][disk_name] = object
+
+          if image
+            object.merge!({
+              "sourceImage" => image.self_link,
+              "sourceImageId" => image.id
+            })
+          end
+          self.data[:disks][disk_name] = object
 
           operation = self.random_operation
           self.data[:operations][operation] = {
             "kind" => "compute#operation",
             "id" => Fog::Mock.random_numbers(19).to_s,
             "name" => operation,
-            "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}",
+            "zone" => object["zone"],
             "operationType" => "insert",
-            "targetLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/disks/#{disk_name}",
+            "targetLink" => object["selfLink"],
             "targetId" => id,
             "status" => Fog::Compute::Google::Operation::PENDING_STATE,
             "user" => "123456789012-qwertyuiopasdfghjkl1234567890qwe@developer.gserviceaccount.com",
             "progress" => 0,
             "insertTime" => Time.now.iso8601,
             "startTime" => Time.now.iso8601,
-            "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/operations/#{operation}"
+            "selfLink" => "#{object["zone"]}/operations/#{operation}"
           }
 
           build_response(:body => self.data[:operations][operation])
@@ -60,26 +72,32 @@ module Fog
           }
 
           if image_name
+            # New disk from image
             image = images.get(image_name)
-            raise ArgumentError.new('Invalid image specified') unless image
+            raise ArgumentError.new("Invalid image specified: #{image_name}") unless image
             @image_url = @api_url + image.resource_url
             parameters['sourceImage'] = @image_url
           end
 
           body_object = { 'name' => disk_name }
 
-          # These must be present if image_name is not specified
+          # According to Google docs, if image name is not present, only one of
+          # sizeGb or sourceSnapshot need to be present, one will create blank
+          # disk of desired size, other will create disk from snapshot
           if image_name.nil?
-            unless opts.has_key?('sourceSnapshot') and opts.has_key?('sizeGb')
-              raise ArgumentError.new('Must specify image OR snapshot and '\
+            if opts.has_key?('sourceSnapshot')
+              # New disk from snapshot
+              snap = snapshots.get(opts.delete('sourceSnapshot'))
+              raise ArgumentError.new('Invalid source snapshot') unless snap
+              body_object['sourceSnapshot'] = @api_url + snap.resource_url
+            elsif opts.has_key?('sizeGb')
+              # New blank disk
+              body_object['sizeGb'] = opts.delete('sizeGb')
+            else
+              raise ArgumentError.new('Must specify image OR snapshot OR '\
                                       'disk size when creating a disk.')
             end
 
-            body_object['sizeGb'] = opts.delete('sizeGb')
-
-            snap = snapshots.get(opts.delete('sourceSnapshot'))
-            raise ArgumentError.new('Invalid source snapshot') unless snap
-            body_object['sourceSnapshot'] = @api_url + snap.resource_url
           end
 
           # Merge in any remaining options (only 'description' should remain)