fog-maestrodev 1.18.0.20131209091424 → 1.18.0.20131218202447

data/lib/fog/google/examples/network.rb

@@ -4,9 +4,20 @@ def test
   # we create a new private network
   connection.insert_network('my-private-network', '10.240.0.0/16')
 
+  name = "fog-smoke-test-#{Time.now.to_i}"
+
+  disk = connection.disks.create({
+    :name => name,
+    :size_gb => 10,
+    :zone_name => 'us-central1-a',
+    :source_image => 'debian-7-wheezy-v20131120',
+  })
+
+  disk.wait_for { disk.ready? }
+
   server = connection.servers.create({
-    :name => "fog-smoke-test-#{Time.now.to_i}",
-    :image_name => "debian-7-wheezy-v20130522",
+    :name => name,
+    :disks => [disk],
     :machine_type => "n1-standard-1",
     :zone_name => "us-central1-a",
     :private_key_path => File.expand_path("~/.ssh/id_rsa"),

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

@@ -57,20 +57,22 @@ module Fog
           end
         end
 
-        def get_as_boot_disk(writable=true)
+        def get_object(writable=true, boot=false, device_name=nil)
           mode = writable ? 'READ_WRITE' : 'READ_ONLY'
           return {
-              'name' => name,
-              'type' => 'PERSISTENT',
-              'boot' => true,
-              'source' => self_link,
-              'mode' => mode
-          }
+            'boot' => boot,
+            'source' => self_link,
+            'mode' => mode,
+            'deviceName' => device_name
+          }.select { |k, v| !v.empty? }
+        end
+
+        def get_as_boot_disk(writable=true)
+          get_object(writable, true)
         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

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

@@ -11,7 +11,6 @@ module Fog
         attribute :kind
         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 +29,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 +48,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/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,10 +16,24 @@ 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'
 
+        def image_name=(args)
+          Fog::Logger.deprecation("image_name= is no longer used [light_black](#{caller.first})[/]")
+        end
+        def image_name
+          Fog::Logger.deprecation("image_name is deprecated, use source_image from boot disk [light_black](#{caller.first})[/]")
+          disks.first.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
@@ -39,7 +53,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 +128,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 +137,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

@@ -45,22 +45,38 @@ module Fog
         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/requests/compute/insert_disk.rb

@@ -9,9 +9,12 @@ module Fog
           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']]
+              if data(project)[:images][image_name]
+                image_project = project
+                break;
+              end
             end
+            raise ArgumentError.new("Invalid image specified: #{image_name}") unless image_project
             get_image(image_name, image_project) # ok if image exists, will fail otherwise
           end
           get_zone(zone_name)
@@ -61,7 +64,7 @@ module Fog
 
           if image_name
             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

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

@@ -19,14 +19,10 @@ module Fog
             'project' => @project,
           }
 
-          kernel_url = @api_url + 'google/global/kernels/' + \
-                      options.delete('preferredKernel').to_s
-
           body_object = {
             'sourceType'      => 'RAW',
             'name'            => image_name,
-            'rawDisk'         => options.delete('rawDisk'),
-            'preferredKernel' => kernel_url,
+            'rawDisk'         => options.delete('rawDisk')
           }
 
           # Merge in the remaining params (only 'description' should remain)

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

@@ -26,15 +26,7 @@ module Fog
 
         def insert_server(server_name, zone_name, options={}, *deprecated_args)
 
-          # check that image and zone exist
-          image_project = nil
-          if options.has_key? 'image'
-            ([ @project ] + Fog::Compute::Google::Images::GLOBAL_PROJECTS).each do |project|
-              image_project = project
-              break if data(project)[:images][options['image']]
-            end
-            get_image(options['image'], image_project) # ok if image exists, will fail otherwise
-          end
+          # check that zone exists
           get_zone(zone_name)
 
           id = Fog::Mock.random_numbers(19).to_s
@@ -47,8 +39,6 @@ module Fog
             "name" => server_name,
             "tags" => { "fingerprint" => "42WmSpB8rSM=" },
             "machineType" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone_name}/machineTypes/#{options['machineType']}",
-            "image" => "https://www.googleapis.com/compute/#{api_version}/projects/#{image_project}/global/images/#{options['image']}",
-            "kernel" => "https://www.googleapis.com/compute/#{api_version}/projects/google/global/kernels/gce-v20130813",
             "canIpForward" => false,
             "networkInterfaces" => [
               {
@@ -113,6 +103,8 @@ module Fog
 
         def handle_disks(options)
           disks = []
+          # An array of persistent disks. You must supply a boot disk as the first disk in
+          # this array and mark it as a boot disk using the disks[].boot property.
           options.delete('disks').each do |disk|
             if disk.is_a? Disk
               disks << disk.get_object
@@ -120,6 +112,7 @@ module Fog
               disks << disk
             end
           end
+          disks.first['boot'] = true
           disks
         end
 
@@ -139,12 +132,6 @@ module Fog
           }
           body_object = {:name => server_name}
 
-          if options.has_key? 'image'
-            image_name = options.delete 'image'
-            image = images.get(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'}"
           network = nil
           if options.has_key? 'network'
@@ -170,15 +157,15 @@ module Fog
           # TODO: add other networks
           body_object['networkInterfaces'] = networkInterfaces
 
-          body_object['disks'] = handle_disks(options) if options['disks']
+          if options['disks'].nil? or options['disks'].empty?
+            raise ArgumentError.new "Empty value for field 'disks'. Boot disk must be specified"
+          end
+          body_object['disks'] = handle_disks(options)
 
           options['metadata'] = format_metadata options['metadata'] if options['metadata']
 
           body_object['tags'] = { 'items' => options.delete('tags') } if options['tags']
 
-          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,

data/lib/fog/openstack/compute.rb

@@ -28,6 +28,8 @@ module Fog
       collection  :addresses
       model       :security_group
       collection  :security_groups
+      model       :security_group_rule
+      collection  :security_group_rules
       model       :key_pair
       collection  :key_pairs
       model       :tenant
@@ -128,6 +130,7 @@ module Fog
       request :create_security_group_rule
       request :delete_security_group
       request :delete_security_group_rule
+      request :get_security_group_rule
 
       # Key Pair
       request :list_key_pairs

data/lib/fog/openstack/models/compute/host.rb

@@ -10,6 +10,7 @@ module Fog
         attribute :host_name
         attribute :service_name
         attribute :details
+        attribute :zone
 
         def initialize(attributes)
           attributes["service_name"] = attributes.delete "service"

data/lib/fog/openstack/models/compute/security_group.rb

@@ -3,16 +3,30 @@ require 'fog/core/model'
 module Fog
   module Compute
     class OpenStack
-
       class SecurityGroup < Fog::Model
 
         identity  :id
 
         attribute :name
         attribute :description
-        attribute :rules
+        attribute :security_group_rules, :aliases => "rules"
         attribute :tenant_id
 
+        def security_group_rules
+          Fog::Compute::OpenStack::SecurityGroupRules.new(:service => service).load(attributes[:security_group_rules])
+        end
+
+        def rules
+          Fog::Logger.deprecation('#rules is deprecated. Use #security_group_rules instead')
+          attributes[:security_group_rules]
+        end
+
+        # no one should be calling this because it doesn't do anything
+        # useful but we deprecated the rules attribute and need to maintain the API
+        def rules=(new_rules)
+          Fog::Logger.deprecation('#rules= is deprecated. Use the Fog::Compute::Openstack::SecurityGroupRules collection to create new rules.')
+          attributes[:security_group_rules] = new_rules
+        end
 
         def save
           requires :name, :description
@@ -21,7 +35,6 @@ module Fog
           true
         end
 
-
         def destroy
           requires :id
           service.delete_security_group(id)
@@ -29,15 +42,16 @@ module Fog
         end
 
         def create_security_group_rule(min, max, ip_protocol = "tcp", cidr = "0.0.0.0/0", group_id = nil)
+          Fog::Logger.deprecation('#create_security_group_rule is deprecated. Use the Fog::Compute::Openstack::SecurityGroupRules collection to create new rules.')
           requires :id
           service.create_security_group_rule(id, ip_protocol, min, max, cidr, group_id)
         end
 
         def delete_security_group_rule(rule_id)
+          Fog::Logger.deprecation('#create_security_group_rule is deprecated. Use the Fog::Compute::Openstack::SecurityGroupRule objects to destroy rules.')
           service.delete_security_group_rule(rule_id)
           true
         end
-
       end
     end
   end

data/lib/fog/openstack/models/compute/security_group_rule.rb

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class OpenStack
+      class SecurityGroupRule < Fog::Model
+        identity :id
+
+        attribute :from_port
+        attribute :group
+        attribute :ip_protocol
+        attribute :to_port
+        attribute :parent_group_id
+        attribute :ip_range
+
+        def save
+          requires :ip_protocol, :from_port, :to_port, :parent_group_id
+          cidr = ip_range && ip_range["cidr"]
+          if rule = service.create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group).data[:body]
+            merge_attributes(rule["security_group_rule"])
+          end
+        end
+
+        def destroy
+          requires :id
+          service.delete_security_group_rule(id)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/security_group_rules.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/openstack/models/compute/security_group_rule'
+
+module Fog
+  module Compute
+    class OpenStack
+      class SecurityGroupRules < Fog::Collection
+
+        model Fog::Compute::OpenStack::SecurityGroupRule
+
+        def get(security_group_rule_id)
+          if security_group_rule_id
+            body = service.get_security_group_rule(security_group_rule_id).body
+            new(body['security_group_rule'])
+          end
+        rescue Fog::Compute::OpenStack::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/network.rb

@@ -118,10 +118,40 @@ module Fog
       class Mock
         def self.data
           @data ||= Hash.new do |hash, key|
+            network_id = Fog::UUID.uuid
+            subnet_id  = Fog::UUID.uuid
+            tenant_id  = Fog::Mock.random_hex(8)
+
             hash[key] = {
-              :networks => {},
+              :networks => {
+                network_id => {
+                  'id'                    => network_id,
+                  'name'                  => 'Public',
+                  'subnets'               => [subnet_id],
+                  'shared'                => true,
+                  'status'                => 'ACTIVE',
+                  'tenant_id'             => tenant_id,
+                  'provider_network_type' => 'vlan',
+                  'router:external'       => false,
+                  'admin_state_up'        => true,
+                }
+              },
               :ports => {},
-              :subnets => {},
+              :subnets => {
+                subnet_id => {
+                  'id'               => subnet_id,
+                  'name'             => "Public",
+                  'network_id'       => network_id,
+                  'cidr'             => "192.168.0.0/22",
+                  'ip_version'       => 4,
+                  'gateway_ip'       => Fog::Mock.random_ip,
+                  'allocation_pools' => [],
+                  'dns_nameservers'  => [Fog::Mock.random_ip, Fog::Mock.random_ip],
+                  'host_routes'      => [Fog::Mock.random_ip],
+                  'enable_dhcp'      => true,
+                  'tenant_id'        => tenant_id,
+                }
+              },
               :floating_ips => {},
               :routers => {},
               :lb_pools => {},
@@ -140,7 +170,7 @@ module Fog
                   "subnet" => 10,
                   "network" => 10,
                   "floatingip" => 50,
-                  "tenant_id" => Fog::Mock.random_hex(8),
+                  "tenant_id" => tenant_id,
                   "router" => 10,
                   "port" => 30
                 }

data/lib/fog/openstack/requests/compute/create_security_group.rb

@@ -23,10 +23,10 @@ module Fog
 
       class Mock
         def create_security_group(name, description)
-          Fog::Identity.new(:provider => 'OpenStack')
+          Fog::Identity::OpenStack.new(:openstack_auth_url => credentials[:openstack_auth_url])
           tenant_id = Fog::Identity::OpenStack::Mock.data[current_tenant][:tenants].keys.first
           security_group_id = Fog::Mock.random_numbers(2).to_i
-          self.data[:security_groups][security_group_id] = {
+          self.data[:security_groups][security_group_id.to_s] = {
             'tenant_id' => tenant_id,
             'rules'     => [],
             'id'        => security_group_id,
@@ -42,7 +42,7 @@ module Fog
             'Content-Length' => Fog::Mock.random_numbers(3).to_s,
             'Date'           => Date.new}
           response.body = {
-            'security_group' => self.data[:security_groups][security_group_id]
+            'security_group' => self.data[:security_groups][security_group_id.to_s]
           }
           response
         end

data/lib/fog/openstack/requests/compute/create_security_group_rule.rb

@@ -47,7 +47,7 @@ module Fog
               'cidr'   => cidr
             }
           }
-          self.data[:security_groups][parent_group_id]['rules'].push(rule)
+          self.data[:security_groups][parent_group_id.to_s]['rules'].push(rule)
           response.body = {
             'security_group_rule' => rule
           }

data/lib/fog/openstack/requests/compute/create_server.rb

@@ -13,7 +13,7 @@ module Fog
           }
 
           vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
-                             'availability_zone', 'user_data', 'key_name', 
+                             'availability_zone', 'user_data', 'key_name',
                              'adminPass', 'config_drive', 'min_count', 'max_count',
                              'return_reservation_id'
                             ]
@@ -107,7 +107,6 @@ module Fog
                        response.body["user"]["id"]
                     end
 
-
           mock_data = {
             'addresses'    => {},
             'flavor'       => {"id" => flavor_ref, "links"=>[{"href"=>"http://nova1:8774/admin/flavors/1", "rel"=>"bookmark"}]},
@@ -127,10 +126,18 @@ module Fog
             'config_drive' => options['config_drive'] || '',
           }
 
+          if nics = options['nics']
+            nics.each do |nic|
+              mock_data["addresses"].merge!(
+                "Public" => [{ 'addr' => Fog::Mock.random_ip }]
+              )
+            end
+          end
+
           response_data = {}
           if options['return_reservation_id'] == 'True' then
             response_data = { 'reservation_id' => "r-#{Fog::Mock.random_numbers(6).to_s}" }
-          else   
+          else
             response_data = {
               'adminPass'       => 'password',
               'id'              => server_id,
@@ -156,12 +163,12 @@ module Fog
           self.data[:last_modified][:servers][server_id] = Time.now
           self.data[:servers][server_id] = mock_data
           if options['return_reservation_id'] == 'True' then
-            response.body = response_data 
+            response.body = response_data
           else
             response.body = { 'server' => response_data }
           end
           response
-        end      
+        end
       end
     end
   end

data/lib/fog/openstack/requests/compute/delete_security_group.rb

@@ -15,7 +15,7 @@ module Fog
 
       class Mock
         def delete_security_group(security_group_id)
-          self.data[:security_groups].delete security_group_id
+          self.data[:security_groups].delete security_group_id.to_s
 
           response = Excon::Response.new
           response.status = 202

data/lib/fog/openstack/requests/compute/delete_security_group_rule.rb

@@ -15,6 +15,8 @@ module Fog
 
       class Mock
         def delete_security_group_rule(security_group_rule_id)
+          security_group = self.data[:security_groups].values.detect{|sg| sg["rules"].detect{ |sgr| sgr["id"].to_s == security_group_rule_id.to_s }}
+          security_group["rules"].reject! { |sgr| sgr["id"] == security_group_rule_id }
           response = Excon::Response.new
           response.status = 202
           response.headers = {

data/lib/fog/openstack/requests/compute/get_security_group.rb

@@ -15,32 +15,22 @@ module Fog
 
       class Mock
         def get_security_group(security_group_id)
+          security_group = self.data[:security_groups][security_group_id.to_s]
           response = Excon::Response.new
-          response.status = 200
-          response.headers = {
-            "X-Compute-Request-Id" => "req-63a90344-7c4d-42e2-936c-fd748bced1b3",
-            "Content-Type" => "application/json",
-            "Content-Length" => "167",
-            "Date" => Date.new
-          }
-          response.body = {
-            "security_group" => {
-              "rules" => [{
-                "from_port" => 44,
-                "group" => {},
-                "ip_protocol" => "tcp",
-                "to_port" => 55,
-                "parent_group_id" => 1,
-                "ip_range" => {
-                  "cidr" => "10.10.10.10/24"
-                }, "id"=>1
-              }],
-              "tenant_id" => "d5183375ab0343f3a0b4b05f547aefc2",
-              "id"=>security_group_id,
-              "name"=>"default",
-              "description"=>"default"
+          if security_group
+            response.status = 200
+            response.headers = {
+              "X-Compute-Request-Id" => "req-63a90344-7c4d-42e2-936c-fd748bced1b3",
+              "Content-Type" => "application/json",
+              "Content-Length" => "167",
+              "Date" => Date.new
             }
-          }
+            response.body = {
+              "security_group" => security_group
+            }
+          else
+            raise Fog::Compute::OpenStack::NotFound, "Security group #{security_group_id} does not exist"
+          end
           response
         end
       end # mock