bbrowning-deltacloud-core 0.0.3.1 → 0.0.4

data/Rakefile

@@ -37,15 +37,22 @@ Rake::TestTask.new("test") { |t|
     'tests/images_test.rb',
     'tests/instances_test.rb',
     'tests/instance_states_test.rb',
+    'tests/url_for_test.rb'
   ]
   t.verbose = true
   t.warning = false
 }
 
-load 'deltacloud-core.gemspec'
 
-Rake::GemPackageTask.new(@spec) do |pkg|
-  pkg.need_tar = true
+@specs = ['ruby', 'java'].inject({}) do |hash, spec_platform|
+  $platform = spec_platform
+  hash.update(spec_platform => Gem::Specification.load('deltacloud-core.gemspec'))
+end
+
+@specs.values.each do |spec|
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
 end
 
 desc "Install API"

data/bin/deltacloudd

@@ -2,7 +2,6 @@
 
 require 'rubygems'
 require 'optparse'
-require 'thin'
 
 options = {
   :env => 'development'
@@ -44,45 +43,78 @@ end
 ENV["API_HOST"] = "localhost" unless ENV["API_HOST"]
 ENV["API_PORT"] = "3001" unless ENV["API_PORT"]
 
+puts "Starting Deltacloud API :: #{ENV["API_DRIVER"]} :: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
+puts
+
 dirname="#{File.dirname(__FILE__)}/.."
+platform = RUBY_PLATFORM[/java/] || 'ruby'
 
-argv_opts = ARGV.clone
-argv_opts << ['start'] unless Thin::Runner.commands.include?(options[0])
-argv_opts << ['--address', ENV["API_HOST"] ]
-argv_opts << ['--port', ENV["API_PORT"] ]
-argv_opts << ['--rackup', 'config.ru' ]
-argv_opts << ['--chdir', dirname ]
-argv_opts << ['-e', options[:env] ]
-argv_opts << ['--threaded', '-D', '--stats', '/stats']
-
-argv_opts.flatten!
-
-if options[:env] == "development"
-  use_rerun = false
-  begin
-    require "rerun"
-    use_rerun = true
-  rescue
-    # Do nothing
-  end
-end
+if platform == 'java'
+  require 'rack'
 
-puts "Starting Deltacloud API :: #{ENV["API_DRIVER"]} :: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
-puts
+  # We can't chdir with webrick so add our root directory
+  # onto the load path
+  $: << dirname
+
+  # Read in config.ru and convert it to an instance of Rack::Builder
+  cfgfile = File.read(File.join(dirname, 'config.ru'))
+  inner_app = eval("Rack::Builder.new {(" + cfgfile + "\n )}.to_app",
+                   nil, 'config.ru')
 
-if use_rerun
-  argv_opts.unshift "thin"
-  command = argv_opts.join(" ")
-  topdir = File::expand_path(File::join(File::dirname(__FILE__), ".."))
-  rerun = Rerun::Runner.new(command, :dir => topdir)
-  rerun.start
-  rerun.join
+  app = Rack::Builder.new {
+    use Rack::CommonLogger # apache-like logging
+    use Rack::Reloader if options[:env] == "development"
+    set :root, dirname # Set Sinatra root since we can't chdir to ../
+    run inner_app
+  }.to_app
+
+  # There's a bug with string ports on JRuby so convert to int
+  # http://jira.codehaus.org/browse/JRUBY-4868
+  port = ENV["API_PORT"].to_i
+
+  puts "=> Ctrl-C to shutdown server"
+  Rack::Handler::WEBrick.run(app,
+                             :Host => ENV["API_HOST"],
+                             :Port => port,
+                             :AccessLog => [])
 else
-  thin = Thin::Runner.new(argv_opts)
+  require 'thin'
+
+  argv_opts = ARGV.clone
+  argv_opts << ['start'] unless Thin::Runner.commands.include?(options[0])
+  argv_opts << ['--address', ENV["API_HOST"] ]
+  argv_opts << ['--port', ENV["API_PORT"] ]
+  argv_opts << ['--rackup', 'config.ru' ]
+  argv_opts << ['--chdir', dirname ]
+  argv_opts << ['-e', options[:env] ]
+  argv_opts << ['--threaded', '-D', '--stats', '/stats']
+
+  argv_opts.flatten!
+
+  if options[:env] == "development"
+    use_rerun = false
+    begin
+      require "rerun"
+      use_rerun = true
+    rescue
+      # Do nothing
+    end
+  end
+
+  if use_rerun
+    argv_opts.unshift "thin"
+    command = argv_opts.join(" ")
+    topdir = File::expand_path(File::join(File::dirname(__FILE__), ".."))
+    rerun = Rerun::Runner.new(command, :dir => topdir)
+    rerun.start
+    rerun.join
+  else
+    thin = Thin::Runner.new(argv_opts)
 
-  begin
-    thin.run!
-  rescue Exception => e
-    puts "ERROR: #{e.message}"
+    begin
+      thin.run!
+    rescue Exception => e
+      puts "ERROR: #{e.message}"
+    end
   end
 end

data/config.ru

@@ -1,5 +1,5 @@
-require 'sinatra'
 require 'rubygems'
+require 'sinatra'
 
 require 'server.rb'
 run Sinatra::Application

data/deltacloud.rb

@@ -9,6 +9,7 @@ require 'deltacloud/models/base_model'
 require 'deltacloud/models/realm'
 require 'deltacloud/models/image'
 require 'deltacloud/models/instance'
+require 'deltacloud/models/key'
 require 'deltacloud/models/instance_profile'
 require 'deltacloud/models/storage_snapshot'
 require 'deltacloud/models/storage_volume'

data/lib/deltacloud/base_driver/base_driver.rb

@@ -31,6 +31,16 @@ module Deltacloud
     end
   end
 
+  class BackendFeatureUnsupported < StandardError
+    attr_reader :code, :cause, :details
+    def initialize(code, cause, message, details)
+      super(message)
+      @code = code
+      @cause = cause
+      @details = details
+    end
+  end
+
   class BaseDriver
 
     def self.define_hardware_profile(name,&block)
@@ -195,6 +205,25 @@ module Deltacloud
       return false
     end
 
+    def catched_exceptions_list
+      { :error => [], :auth => [], :glob => [] }
+    end
+
+    def safely(&block)
+      begin
+        block.call
+      rescue *catched_exceptions_list[:error] => e
+        raise Deltacloud::BackendError.new(502, e.class.to_s, e.message, e.backtrace)
+      rescue *catched_exceptions_list[:auth] => e
+        raise Deltacloud::AuthException.new
+      rescue => e
+        catched_exceptions_list[:glob].each do |ex|
+          raise Deltacloud::BackendError.new(502, e.class.to_s, e.message, e.backtrace) if e.class.name =~ ex
+        end
+        raise e
+      end
+    end
+
   end
 
 end

data/lib/deltacloud/base_driver/features.rb

@@ -120,6 +120,13 @@ module Deltacloud
     #
     # Declaration of optional features
     #
+    declare_feature :images,  :owner_id do
+      description "Filter images using owner id"
+      operation :index do
+        param :owner_id,  :string,  :optional,  nil,  "Owner ID"
+      end
+    end
+
     declare_feature :instances, :user_name do
       description "Accept a user-defined name on instance creation"
       operation :create do

data/lib/deltacloud/base_driver/mock_driver.rb

@@ -11,10 +11,13 @@ module Mock
       [
         :describe_images,
         :describe_availability_zones,
+        :describe_keypairs,
+        :create_keypair,
         :run_instances,
         :describe_instances,
         :reboot_instances,
-        :terminate_instances
+        :terminate_instances,
+        :delete_keypair
       ]
     end
 

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

@@ -35,8 +35,13 @@ module Deltacloud
     module EC2
 class EC2Driver < Deltacloud::BaseDriver
 
+  def supported_collections
+    DEFAULT_COLLECTIONS + [ :keys ]
+  end
+
   feature :instances, :user_data
   feature :instances, :authentication_key
+  feature :images, :owner_id
 
   define_hardware_profile('m1.small') do
     cpu                1
@@ -170,40 +175,60 @@ class EC2Driver < Deltacloud::BaseDriver
   def create_instance(credentials, image_id, opts)
     ec2 = new_client( credentials )
     realm_id = opts[:realm_id]
-    image = image(credentials, :id => image_id )
-    hwp = find_hardware_profile(credentials, opts[:hwp_id], image.id)
-    ec2_instances = ec2.run_instances(
-      :image_id => image.id,
-      :user_data => opts[:user_data],
-      :key_name => opts[:keyname],
-      :availability_zone => realm_id,
-      :monitoring_enabled => true,
-      :instance_type => hwp.name,
-      :disable_api_termination => false,
-      :instance_initiated_shutdown_behavior => 'terminate'
-    )
-    convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
+    safely do
+      image = image(credentials, :id => image_id )
+      hwp = find_hardware_profile(credentials, opts[:hwp_id], image.id)
+      ec2_instances = ec2.run_instances(
+        :image_id => image.id,
+        :user_data => opts[:user_data],
+        :key_name => opts[:keyname],
+        :availability_zone => realm_id,
+        :monitoring_enabled => true,
+        :instance_type => hwp.name,
+        :disable_api_termination => false,
+        :instance_initiated_shutdown_behavior => 'terminate'
+      )
+      return convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
+    end
+  end
+
+  def generate_instance(ec2, id, backup)
+    begin
+      this_instance = ec2.describe_instances( :instance_id => id ).reservationSet.item.first.instancesSet.item.first
+      convert_instance(this_instance, this_instance.ownerId)
+    rescue Exception => e
+      puts "WARNING: ignored error during instance refresh: #{e.message}"
+      # at this point, the action has succeeded but our follow-up
+      # "describe_instances" failed for some reason.  Create a simple Instance
+      # object with only the ID and new state in place
+      state = backup.instancesSet.item.first.currentState.name
+      Instance.new( {
+        :id => id,
+        :state => state,
+        :actions => instance_actions_for( state ),
+      } )
+    end
   end
 
   def reboot_instance(credentials, id)
     ec2 = new_client(credentials)
-    safely do
-      ec2.reboot_instances( :instance_id => id )
-    end
+    backup = ec2.reboot_instances( :instance_id => id )
+
+    generate_instance(ec2, id, backup)
   end
 
   def stop_instance(credentials, id)
     ec2 = new_client(credentials)
-    safely do
-      ec2.terminate_instances( :instance_id => id )
-    end
+    backup = ec2.terminate_instances( :instance_id => id )
+
+    generate_instance(ec2, id, backup)
   end
 
   def destroy_instance(credentials, id)
     ec2 = new_client(credentials)
-    safely do
-      ec2.terminate_instances( :instance_id => id )
-    end
+    backup = ec2.terminate_instances( :instance_id => id )
+
+    generate_instance(ec2, id, backup)
   end
 
   #
@@ -252,6 +277,39 @@ class EC2Driver < Deltacloud::BaseDriver
     snapshots
   end
 
+  def key(credentials, opts=nil)
+    keys(credentials, opts).first
+  end
+
+  def keys(credentials, opts=nil)
+    ec2 = new_client( credentials )
+    opts[:key_name] = opts[:id] if opts and opts[:id]
+    keypairs = ec2.describe_keypairs(opts || {})
+    result = []
+    safely do
+      keypairs.keySet.item.each do |keypair|
+        result << convert_key(keypair)
+      end
+    end
+    result
+  end
+
+  def create_key(credentials, opts={})
+    key = Key.new
+    ec2 = new_client( credentials )
+    safely do
+      key = convert_key(ec2.create_keypair(opts))
+    end
+    return key
+  end
+
+  def destroy_key(credentials, opts={})
+    safely do
+      ec2 = new_client( credentials )
+      ec2.delete_keypair(opts)
+    end
+  end
+
   private
 
   def new_client(credentials)
@@ -260,7 +318,18 @@ class EC2Driver < Deltacloud::BaseDriver
       :secret_access_key => credentials.password
     }
     opts[:server] = ENV['DCLOUD_EC2_URL'] if ENV['DCLOUD_EC2_URL']
-    AWS::EC2::Base.new(opts)
+    safely do
+      AWS::EC2::Base.new(opts)
+    end
+  end
+
+  def convert_key(key)
+    Key.new({
+      :id => key['keyName'],
+      :fingerprint => key['keyFingerprint'],
+      :credential_type => :key,
+      :pem_rsa_key => key['keyMaterial']
+    })
   end
 
   def convert_image(ec2_image)
@@ -326,14 +395,12 @@ class EC2Driver < Deltacloud::BaseDriver
     } )
   end
 
-  def safely(&block)
-    begin
-      block.call
-    rescue AWS::AuthFailure => e
-        raise Deltacloud::AuthException.new
-    rescue Exception => e
-        puts "ERROR: #{e.message}\n#{e.backtrace.join("\n")}"
-    end
+  def catched_exceptions_list
+    {
+      :auth => [ AWS::AuthFailure ],
+      :error => [],
+      :glob => [ /AWS::(\w+)/ ]
+    }
   end
 
 end

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

@@ -9,7 +9,7 @@ class GoGridClient
                  apikey='YOUR API KEY',
                  secret='YOUR SHARED SECRET', 
                  format='json',
-                 version='1.4')
+                 version='1.5')
     @server = server
     @secret = secret
     @default_params = {'format'=>format, 'v'=>version,'api_key' => apikey}
@@ -30,7 +30,12 @@ class GoGridClient
     open(getRequestURL(method,params)).read
   end
 
-  def request(method, params={})
+  def request(method, params={}, version=nil)
+    if version
+      @default_params['v'] = version
+    else
+      @default_params['v'] = '1.5'
+    end
     begin
       JSON::parse(sendAPIRequest(method, params))
     rescue Exception => e

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

@@ -44,20 +44,8 @@ class GogridDriver < Deltacloud::BaseDriver
   end
 
   def supported_collections
-    DEFAULT_COLLECTIONS.reject { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
-  end
-
-  # The only valid option for flavors is server RAM for now
-  def flavors(credentials, opts=nil)
-    flavors = []
-    safely do
-      flavors=new_client(credentials).request('common/lookup/list', { 'lookup' => 'server.ram' })['list'].collect do |flavor|
-        convert_flavor(flavor)
-      end
-    end
-    flavors = filter_on( flavors, :id, opts )
-    flavors = filter_on( flavors, :architecture, opts )
-    flavors
+    DEFAULT_COLLECTIONS.reject! { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
+    DEFAULT_COLLECTIONS + [ :keys ]
   end
 
   def images(credentials, opts=nil)
@@ -79,7 +67,7 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def realms(credentials, opts=nil)
     safely do
-      new_client(credentials).request('common/lookup/list', { 'lookup' => 'image.type' })['list'].collect do |realm|
+      new_client(credentials).request('common/lookup/list', { 'lookup' => 'ip.datacenter' })['list'].collect do |realm|
         convert_realm(realm)
       end
     end
@@ -100,7 +88,7 @@ class GogridDriver < Deltacloud::BaseDriver
         'name' => name,
         'image' => image_id,
         'server.ram' => server_ram,
-        'ip' => get_next_free_ip(credentials)
+        'ip' => get_free_ip_from_realm(credentials, opts[:realm_id] || '1')
       })['list'].first
       if instance
         login_data = get_login_data(client, instance[:id])
@@ -132,6 +120,7 @@ class GogridDriver < Deltacloud::BaseDriver
   end
 
   def instances(credentials, opts=nil)
+    require 'ap'
     instances = []
     if opts and opts[:id]
       begin
@@ -166,26 +155,41 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def reboot_instance(credentials, id)
     safely do
-      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'reboot'})
+      new_client(credentials).request('grid/server/power', { 'name' => id, 'power' => 'reboot'})
     end
   end
 
   def destroy_instance(credentials, id)
     safely do
-      new_client(credentials).request('grid/server/delete', { 'id' => id})
+      new_client(credentials).request('grid/server/delete', { 'name' => id})
     end
   end
 
   def stop_instance(credentials, id)
     safely do
-      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'off'})
+      new_client(credentials).request('grid/server/power', { 'name' => id, 'power' => 'off'})
     end
   end
 
   def start_instance(credentials, id)
     safely do
-      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'on'})
+      new_client(credentials).request('grid/server/power', { 'name' => id, 'power' => 'on'})
+    end
+  end
+
+  def key(credentials, opts=nil)
+    keys(credentials, opts).first
+  end
+
+  def keys(credentials, opts=nil)
+    gogrid = new_client( credentials )
+    creds = []
+    safely do
+      gogrid.request('support/password/list')['list'].each do |password|
+        creds << convert_key(password)
+      end
     end
+    return creds
   end
 
   define_instance_states do
@@ -201,6 +205,7 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def new_client(credentials)
     GoGridClient.new('https://api.gogrid.com/api', credentials.user, credentials.password)
+
   end
 
   def get_login_data(client, instance_id)
@@ -219,6 +224,15 @@ class GogridDriver < Deltacloud::BaseDriver
     return login_data
   end
 
+  def convert_key(password)
+    Key.new({
+      :id => password['id'],
+      :username => password['username'],
+      :password => password['password'],
+      :credential_type => :password
+    })
+  end
+
   def convert_image(gg_image, owner_id=nil)
     Image.new( {
       :id=>gg_image['id'],
@@ -237,15 +251,6 @@ class GogridDriver < Deltacloud::BaseDriver
     end
   end
 
-  def convert_flavor(flavor)
-    Flavor.new(
-      :id => flavor['id'],
-      :architecture => 'x86',
-      :memory => flavor['name'].tr('G', ''),
-      :storage => '1'
-    )
-  end
-
   def convert_realm(realm)
     Realm.new(
       :id => realm['id'],
@@ -279,10 +284,9 @@ class GogridDriver < Deltacloud::BaseDriver
       :id => instance['name'],
       :owner_id => owner_id,
       :image_id => instance['image']['id'],
-      :flavor_id => instance['ram']['id'],
       :instance_profile => prof,
       :name => instance['name'],
-      :realm_id => instance['type']['id'],
+      :realm_id => instance['ip']['datacenter']['id'],
       :state => convert_server_state(instance['state']['name'], instance['id']),
       :actions => instance_actions_for(convert_server_state(instance['state']['name'], instance['id'])),
       :public_addresses => [ instance['ip']['ip'] ],
@@ -301,12 +305,13 @@ class GogridDriver < Deltacloud::BaseDriver
     state.eql?('Off') ? 'STOPPED' : 'RUNNING'
   end
 
-  def get_next_free_ip(credentials)
+  def get_free_ip_from_realm(credentials, realm_id)
     ip = ""
     safely do
       ip = new_client(credentials).request('grid/ip/list', {
         'ip.type' => '1',
-        'ip.state' => '1'
+        'ip.state' => '1',
+        'datacenter' => realm_id
       })['list'].first['ip']
     end
     return ip
@@ -316,7 +321,7 @@ class GogridDriver < Deltacloud::BaseDriver
     begin
       block.call
     rescue Exception => e
-      puts "ERROR: #{e.message}"
+      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
     end
   end