deltacloud-core 1.1.0 → 1.1.1

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -53,6 +53,7 @@ module Deltacloud
           memory             613
           storage            160
           architecture       ['i386','x86_64']
+          root_type          :persistent
         end
 
         define_hardware_profile('m1.small') do
@@ -301,7 +302,7 @@ module Deltacloud
           target = instance(credentials, :id => opts[:id])
           param = {}
           param[:credentials] = {
-            :username => 'root', # Default for EC2 Linux instances
+            :username => (opts[:username]) ? opts[:username] : 'root', # Default for EC2 Linux instances
           }
           param[:port] = opts[:port] || '22'
           param[:ip] = opts[:ip] || target.public_addresses.first.address
@@ -379,7 +380,11 @@ module Deltacloud
         def create_key(credentials, opts={})
           ec2 = new_client(credentials)
           safely do
-            convert_key(ec2.create_key_pair(opts[:key_name]))
+            if (opts[:public_key] && opts[:public_key].length >0)
+              convert_key(ec2.import_key_pair(opts[:key_name], opts[:public_key]))
+            else
+              convert_key(ec2.create_key_pair(opts[:key_name]))
+            end
           end
         end
 
@@ -938,10 +943,15 @@ module Deltacloud
             :owner_id => image[:aws_owner],
             :architecture => image[:aws_architecture],
             :hardware_profiles => image_profiles(image, profiles),
-            :state => image[:aws_state]
+            :state => image[:aws_state],
+            :root_type => convert_root_type(image[:aws_root_device_type])
           )
         end
 
+        def convert_root_type(type)
+          type == 'ebs' ? 'persistent' : 'transient'
+        end
+
         def convert_instance(instance)
           can_create_image = 'ebs'.eql?(instance[:root_device_type]) and 'RUNNING'.eql?(convert_state(instance[:aws_state]))
           inst_profile_opts={}
@@ -1146,6 +1156,11 @@ module Deltacloud
         end
 
         exceptions do
+
+          on /root device is not supported for the instance/ do
+            status 400
+          end
+
           on /(AuthFailure|InvalidAccessKeyId)/ do
             status 401
           end

data/lib/deltacloud/drivers/eucalyptus/eucalyptus_driver.rb

@@ -118,6 +118,31 @@ module Deltacloud
                   "Loadbalancer not supported in Eucalyptus", "")
         end
 
+        #override ec2 driver realms - euca API doesn't support vpc/subnet concepts
+        #http://docs.aws.amazon.com/AWSEC2/2009-04-04/DeveloperGuide/
+        def realms(credentials, opts={})
+          ec2 = new_client(credentials)
+          realms = []
+          safely do
+            if opts[:id] and !opts[:id].empty?
+              begin
+                ec2.describe_availability_zones([opts[:id]]).collect do |realm|
+                  realms << convert_realm(realm) unless realm.empty?
+                end
+              rescue => e
+                raise e unless e.message =~ /Invalid availability zone/
+                realms = []
+              end
+            else
+              realms = ec2.describe_availability_zones.collect do |realm|
+                convert_realm(realm) unless realm.empty?
+              end
+            end
+          end
+          realms
+        end
+
+
 	# override EC2 implementation; Eucalyptus implements the older definition of EC2 security group;
 	# http://docs.amazonwebservices.com/AWSEC2/2009-07-15/APIReference/index.html?ApiReference-query-AuthorizeSecurityGroupIngress.html
         # if the rule specifies a source group, port&protocol will be ignored. And source group and cidr range can't be mixed in a request

data/lib/deltacloud/drivers/fgcp/fgcp_client.rb

@@ -167,7 +167,7 @@ class FgcpClient
       <description>#{description}</description>
     </locale>
     <locale>
-      <lcid>jp</lcid>
+      <lcid>ja</lcid>
       <name>#{name}</name>
       <description>#{description}</description>
     </locale>

data/lib/deltacloud/drivers/fgcp/fgcp_driver.rb

@@ -60,6 +60,7 @@ class FgcpDriver < Deltacloud::BaseDriver
     stopping.to( :stopped )       .automatically  # stopping an instance does not automatically destroy it
     stopped.to(:running)          .on( :start )   # obvious
     stopped.to(:finish)           .on( :destroy ) # only destroy removes an instance, and it has to be stopped first
+    error.from( :pending, :running, :stopping)    # not including STOP_ERROR and START_ERROR as they are as :running and :stopped
   end
 
   ######################################################################
@@ -108,6 +109,13 @@ class FgcpDriver < Deltacloud::BaseDriver
       if xml['diskimages'] # not likely to not be so, but just in case
         xml['diskimages'][0]['diskimage'].each do |img|
 
+          # 32bit CentOS/RHEL images are refused on hwps > 16GB (i.e. w_high, quad_high)
+          os_arch = img['osName'][0].to_s =~ /.*32.?bit.*/ ? 'i386' : 'x86_64'
+          os_centos_rhel = img['osName'][0] =~ /(CentOS|Red Hat).*/
+          allowed_hwps = hwps.select do |hwp|
+            hwp.memory.default.to_i < 16000 or os_arch == 'x86_64' or not os_centos_rhel
+          end
+
           images << Image.new(
             :id => img['diskimageId'][0],
             :name => img['diskimageName'][0].to_s,
@@ -117,8 +125,8 @@ class FgcpDriver < Deltacloud::BaseDriver
             # This will determine image architecture using OS name.
             # Usually the OS name includes '64bit' or '32bit'. If not,
             # it will fall back to 64 bit.
-            :architecture => img['osName'][0].to_s =~ /.*32.?bit.*/ ? 'i386' : 'x86_64',
-            :hardware_profiles => hwps
+            :architecture => os_arch,
+            :hardware_profiles => allowed_hwps
           ) if opts[:id].nil? or opts[:id] == img['diskimageId'][0]
         end
       end
@@ -138,7 +146,7 @@ class FgcpDriver < Deltacloud::BaseDriver
       if opts[:name].nil?
         # default to instance name
         instance = client.get_vserver_attributes(opts[:id])
-        opts[:name] ||= instance['vserver'][0]['vserverName']
+        opts[:name] = instance['vserver'][0]['vserverName']
         opts[:description] ||= opts[:name]
       end
 
@@ -449,7 +457,9 @@ class FgcpDriver < Deltacloud::BaseDriver
         end
         state = client.get_vdisk_status(opts[:id])['vdiskStatus'][0]
         actions = []
-        if state == 'NORMAL'
+        #align with EC2, cimi
+        case state
+        when 'NORMAL'
           if vdisk['attachedTo'].nil?
             state = 'AVAILABLE'
             actions = [:attach, :destroy]
@@ -457,6 +467,10 @@ class FgcpDriver < Deltacloud::BaseDriver
             state = 'IN-USE'
             actions = [:detach]
           end
+        when 'DEPLOYING'
+          state = 'CREATING'
+        when 'BACKUP_ING'
+          state = 'CAPTURING'
         end
 
         volumes << StorageVolume.new(
@@ -490,7 +504,7 @@ class FgcpDriver < Deltacloud::BaseDriver
                 :realm_id    => client.extract_vsys_id(vdisk['vdiskId'][0]),
                 # aligning with rhevm, which returns 'system' or 'data'
                 :kind        => determine_storage_type(vdisk['vdiskId'][0]),
-                :state       => vdisk['attachedTo'].nil? ? nil : 'IN-USE'
+                :state       => vdisk['attachedTo'].nil? ? 'AVAILABLE' : 'IN-USE'
               )
             end
           end
@@ -502,7 +516,7 @@ class FgcpDriver < Deltacloud::BaseDriver
 
   def create_storage_volume(credentials, opts={})
     opts ||= {}
-    opts[:name]     ||= Time.now.to_s
+    opts[:name] = Time.now.to_s unless opts[:name] and not opts[:name].empty?
     opts[:capacity] ||= '1' # DC default
     #size has to be a multiple of 10: round up.
     opts[:capacity] = ((opts[:capacity].to_f / 10.0).ceil * 10.0).to_s
@@ -528,7 +542,8 @@ class FgcpDriver < Deltacloud::BaseDriver
         :capacity    => opts[:capacity],
         :realm_id    => client.extract_vsys_id(opts[:realm_id]),
         :instance_id => nil,
-        :state       => 'DEPLOYING',
+        # aligning with ec2, cimi (instead of fgcp's DEPLOYING)
+        :state       => 'CREATING',
         # aligning with rhevm, which returns 'system' or 'data'
         :kind        => 'data',
         :actions     => []
@@ -577,7 +592,7 @@ class FgcpDriver < Deltacloud::BaseDriver
 
               snapshots << StorageSnapshot.new(
                 :id => opts[:id],
-                #:state => ?,
+                :state => 'AVAILABLE',
                 :storage_volume_id => vdisk_id,
                 :created => backup['backupTime'][0]
               ) if backup_id = backup['backupId'][0]
@@ -603,7 +618,7 @@ class FgcpDriver < Deltacloud::BaseDriver
 
                   snapshots << StorageSnapshot.new(
                     :id => generate_snapshot_id(vdisk['vdiskId'][0], backup['backupId'][0]),
-                    #:state => ?,
+                    :state => 'AVAILABLE',
                     :storage_volume_id => vdisk['vdiskId'][0],
                     :created => backup['backupTime'][0]
                   )
@@ -626,7 +641,7 @@ class FgcpDriver < Deltacloud::BaseDriver
 
     StorageSnapshot.new(
       :id                 => "PENDING-#{opts[:volume_id]}", # don't know id until backup completed
-      :state              => 'PENDING', # OK to make up a state like that?
+      :state              => 'CREATING',
       :storage_volume_id  => opts[:volume_id],
       :created            => Time.now.to_s
     )
@@ -1443,6 +1458,11 @@ eofwopxml
       status 404 # Not Found
     end
 
+    # trying to create an image that has never been booted
+    on /NEVER_BOOTED/ do
+      status 409 # Conflict
+    end
+
     # reached maximum number of attempts while polling for an update
     on /Server did not include public IP address in FW NAT rules/ do
       status 504 # Gateway Timeout
@@ -1629,7 +1649,7 @@ eofwopxml
       :firewalls => server != 'FW' ? [client.extract_vsys_id(vserver['vserverId'][0]) + '-S-0001'] : nil,
       :owner_id => vserver['creator'][0]
     }
-    instance.merge!( {'create_image' => false}) if not server == 'vserver'
+    instance.merge!( {'create_image' => false}) if server != 'vserver' or state_data[:state] != 'STOPPED'
     instance.merge! state_data
 
     Instance::new(instance)
@@ -1705,9 +1725,9 @@ eofwopxml
     'UNEXPECTED_STOP' =>  'STOPPED',
     'RESTORING'       =>  'PENDING',
     'BACKUP_ING'      =>  'PENDING',
-    'ERROR'           =>  'STOPPED',
-    'START_ERROR'     =>  'STOPPED', # not sure about this one
-    'STOP_ERROR'      =>  'STOPPING',
+    'ERROR'           =>  'ERROR',   # allowed actions limited
+    'START_ERROR'     =>  'STOPPED', # allowed actions are same as for STOPPED
+    'STOP_ERROR'      =>  'RUNNING', # allowed actions are same as for RUNNING
     'REGISTERING'     =>  'PENDING',
     'CHANGE_TYPE'     =>  'PENDING'
   }

data/lib/deltacloud/drivers/gogrid/gogrid_driver.rb

@@ -86,6 +86,8 @@ module Deltacloud
               end
             end
           end
+          profiles = hardware_profiles(credentials)
+          imgs.each { |img| img.hardware_profiles = profiles }
           imgs = filter_on( imgs, :architecture, opts )
           imgs.sort_by{|e| [e.owner_id, e.description]}
         end

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -205,11 +205,11 @@ module Deltacloud::Drivers::Mock
       hwp ||= find_hardware_profile(credentials, 'm1-small', image_id)
 
       name = opts[:name] || "i-#{Time.now.to_i}"
-
+      initial_state = opts[:initial_state] || "RUNNING"
       instance = {
         :id => next_id,
         :name=>name,
-        :state=>'RUNNING',
+        :state=> (initial_state == "STARTED" ? "RUNNING" : initial_state),
         :keyname => opts[:keyname],
         :image_id=>image_id,
         :owner_id=>credentials.user,
@@ -218,7 +218,7 @@ module Deltacloud::Drivers::Mock
         :instance_profile => InstanceProfile.new(hwp.name, opts),
         :realm_id=>realm_id,
         :create_image=>true,
-        :actions=>instance_actions_for( 'RUNNING' ),
+        :actions=>instance_actions_for((initial_state == "STARTED" ? "RUNNING" : initial_state)),
         :user_data => opts[:user_data] ? Base64::decode64(opts[:user_data]) : nil
       }
       @client.store(:instances, instance)

data/lib/deltacloud/drivers/openstack/openstack_driver.rb

@@ -16,7 +16,6 @@
 
 require 'openstack'
 require 'tempfile'
-require 'base64'
 
 module Deltacloud
   module Drivers
@@ -44,20 +43,11 @@ module Deltacloud
         end
 
         define_hardware_profile('default')
-
         def supported_collections(credentials)
           #get the collections as defined by 'capability' and 'respond_to?' blocks
           super_collections = super
-          begin
-             new_client(credentials, "object-store")
-          rescue Deltacloud::Exceptions::NotImplemented #OpenStack::Exception::NotImplemented...
-             super_collections = super_collections - [Sinatra::Rabbit::BucketsCollection]
-          end
-          begin
-              new_client(credentials, "volume")
-          rescue Deltacloud::Exceptions::NotImplemented
-              super_collections = super_collections - [Sinatra::Rabbit::StorageVolumesCollection]
-          end
+          super_collections = super_collections - [Sinatra::Rabbit::BucketsCollection] if regions_for(credentials, "object-store").empty?
+          super_collections = super_collections - [Sinatra::Rabbit::StorageVolumesCollection] if regions_for(credentials, "volume").empty?
           super_collections
         end
 
@@ -127,21 +117,42 @@ module Deltacloud
 
         def realms(credentials, opts={})
           os = new_client(credentials)
-          limits = ""
-          safely do
-            lim = os.limits
-              limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
-              lim[:rate].each do |rate|
-                if rate[:regex] =~ /servers/
-                  limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
-                end
-              end
+          realms = []
+          if opts[:id]
+            resource_types = []
+            (os.connection.regions_list[opts[:id]] || []).each do |service|
+              resource_types << service[:service] if ["compute", "volume", "object-store"].include?(service[:service])
+              realms << Realm.new( {  :id => opts[:id],
+                                    :name => opts[:id],
+                                    :state =>'AVAILABLE',
+                                    :resource_types => resource_types}) unless resource_types.empty?
+            end
+          else
+            os.connection.regions_list.each_pair do |region, services|
+              resource_types = services.inject([]){|res, cur| res << cur[:service] if ["compute", "volume", "object-store"].include?(cur[:service]); res }
+              next if resource_types.empty? #nothing here deltacloud manages
+              realms << Realm.new( {  :id => region,
+                                    :name => region,
+                                    :state =>'AVAILABLE',
+                                    :resource_types => resource_types})
+            end
           end
-          return [] if opts[:id] and opts[:id] != 'default'
-          [ Realm.new( { :id=>'default',
-                        :name=>'default',
-                        :limit => limits,
-                        :state=>'AVAILABLE' })]
+          realms
+#          limits = ""
+#          safely do
+#            lim = os.limits
+#              limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
+#              lim[:rate].each do |rate|
+#                if rate[:regex] =~ /servers/
+#                  limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
+#                end
+#              end
+#          end
+#          return [] if opts[:id] and opts[:id] != 'default'
+#          [ Realm.new( { :id=>'default',
+#                        :name=>'default',
+#                        :limit => limits,
+#                        :state=>'AVAILABLE' })]
         end
 
         def instances(credentials, opts={})
@@ -167,7 +178,13 @@ module Deltacloud
         end
 
         def create_instance(credentials, image_id, opts)
-          os = new_client( credentials )
+          if opts[:realm_id] && opts[:realm_id].length > 0
+            os = new_client( credentials, "compute", opts[:realm_id])
+          else
+            #choose a random realm:
+            available_realms = regions_for(credentials, "compute")
+            os = new_client(credentials, "compute", available_realms.sample.id)
+          end
           result = nil
 #opts[:personality]: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
           params = {}
@@ -183,15 +200,16 @@ module Deltacloud
             params[:key_name]=opts[:keyname]
           end
           if opts[:user_data] && opts[:user_data].length > 0
-            params[:user_data]=Base64.encode64(opts[:user_data])
+            params[:user_data]=opts[:user_data]
           end
           safely do
             server = os.create_server(params)
-            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os))
+            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os), os.connection.region)
           end
           result
         end
 
+
         def reboot_instance(credentials, instance_id)
           os = new_client(credentials)
           safely do
@@ -435,26 +453,48 @@ module Deltacloud
 
         def storage_snapshots(credentials, opts={})
           vs = new_client(credentials, "volume")
+          snapshots = []
           safely do
+            if opts[:id]
+              snapshots <<  convert_snapshot(vs.get_snapshot(opts[:id]))
+            else
+              vs.snapshots.each do |snap|
+                snapshots << convert_snapshot(snap)
+              end
+            end
           end
+          snapshots
         end
 
         def create_storage_snapshot(credentials, opts={})
           vs = new_client(credentials, "volume")
           safely do
+            name = opts[:name] || "snapshot_#{Time.now.to_i}"
+            description = opts[:description] || "snapshot from volume #{opts[:volume_id]}"
+            params = {:volume_id => opts[:volume_id], :display_name=>name, :display_description=>description}
+            convert_snapshot(vs.create_snapshot(params))
           end
         end
 
         def destroy_storage_snapshot(credentials, opts={})
           vs = new_client(credentials, "volume")
           safely do
+            vs.delete_snapshot(opts[:id])
           end
         end
 
 private
 
+        def region_specified?
+          api_provider.split(";").last
+        end
+
+        def regions_for(credentials, service="compute")
+          realms(credentials).select{|region| region.resource_types.include?(service)}
+        end
+
         #for v2 authentication credentials.name == "username+tenant_name"
-        def new_client(credentials, type = "compute")
+        def new_client(credentials, type="compute", realm_id=nil)
           tokens = credentials.user.split("+")
           if credentials.user.empty?
             raise AuthenticationFailure.new(Exception.new("Error: you must supply the username"))
@@ -464,10 +504,18 @@ private
           else
             user_name, tenant_name = tokens.first, tokens.last
           end
+          #check if region specified with provider:
+          provider = api_provider
+          if (realm_id || provider.include?(";"))
+            region = realm_id || provider.split(";").last
+            provider = provider.chomp(";#{region}")
+          end
+          connection_params = {:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => provider, :service_type => type}
+          connection_params.merge!({:region => region}) if region
           safely do
             raise ValidationFailure.new(Exception.new("Error: tried to initialise Openstack connection using" +
                     " an unknown service_type: #{type}")) unless ["volume", "compute", "object-store"].include? type
-            OpenStack::Connection.create(:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => api_provider, :service_type => type)
+            OpenStack::Connection.create(connection_params)
            end
         end
 
@@ -500,7 +548,7 @@ private
                     })
         end
 
-        def convert_from_server(server, owner, attachments=[])
+        def convert_from_server(server, owner, attachments=[], region=nil)
           op = (server.class == Hash)? :fetch : :send
           image = server.send(op, :image)
           flavor = server.send(op, :flavor)
@@ -511,7 +559,7 @@ private
           end
           inst = Instance.new(
             :id => server.send(op, :id).to_s,
-            :realm_id => 'default',
+            :realm_id => region || "n/a",
             :owner_id => owner,
             :description => server.send(op, :name),
             :name => server.send(op, :name),
@@ -524,6 +572,7 @@ private
             :username => 'root',
             :password => password,
             :keyname => server.send(op, :key_name),
+            :launch_time => server.send(op, :created),
             :storage_volumes => attachments.inject([]){|res, cur| res << {cur[:volumeId] => cur[:device]} ;res}
           )
           inst.actions = instance_actions_for(inst.state)
@@ -607,6 +656,17 @@ private
           })
         end
 
+        def convert_snapshot(snapshot)
+          StorageSnapshot.new(
+            :id => snapshot.id,
+            :name => snapshot.display_name,
+            :description => snapshot.display_description || snapshot.display_name,
+            :state => snapshot.status,
+            :storage_volume_id => snapshot.volume_id,
+            :created => snapshot.created_at
+          )
+        end
+
         #IN: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
         #OUT:{local_path=>server_path, local_path1=>server_path2 etc}
         def extract_personality(opts)