deltacloud-core 1.0.3 → 1.0.4

data/lib/deltacloud/collections/drivers.rb

@@ -25,7 +25,7 @@ module Deltacloud::Collections
             format.xml { haml :"drivers/index" }
             format.json { @drivers.to_json }
             format.html { haml :"drivers/index" }
-          end 
+          end
         end
       end
 

data/lib/deltacloud/collections/firewalls.rb

@@ -22,7 +22,7 @@ module Deltacloud::Collections
 
     check_features :for => lambda { |c, f| driver.class.has_feature?(c, f) }
 
-    get route_for('/firewalls/:id/new_rule') do
+    get '/firewalls/:id/new_rule' do
       @firewall_name = params[:id]
       respond_to do |format|
         format.html {haml :"firewalls/new_rule" }

data/lib/deltacloud/collections/instances.rb

@@ -31,7 +31,7 @@ module Deltacloud::Collections
       @keys = driver.keys(credentials) if driver.class.has_feature? :instances, :authentication_key
     end
 
-    get route_for('/instances/:id/run') do
+    get '/instances/:id/run' do
       respond_to do |format|
         @instance = driver.instances(credentials, :id => params[:id]).first
         format.html {haml :"instances/run_command" }
@@ -77,16 +77,19 @@ module Deltacloud::Collections
 
       action :reboot, :with_capability => :reboot_instance do
         description "Reboot a running instance."
+        param :id, :string, :required
         control { instance_action(:reboot) }
       end
 
       action :start, :with_capability => :start_instance do
         description "Start an instance."
+        param :id, :string, :required
         control { instance_action(:start) }
       end
 
       action :stop, :with_capability => :stop_instance do
         description "Stop a running instance."
+        param :id, :string, :required
         control { instance_action(:stop) }
       end
 
@@ -95,6 +98,7 @@ module Deltacloud::Collections
       end
 
       action :run, :with_capability => :run_on_instance do
+        param :id,          :string,  :required
         param :cmd,         :string,  :required, [], "Shell command to run on instance"
         param :private_key, :string,  :optional, [], "Private key in PEM format for authentication"
         param :password,    :string,  :optional, [], "Password used for authentication"

data/lib/deltacloud/collections/keys.rb

@@ -21,7 +21,7 @@ module Deltacloud::Collections
     set :capability, lambda { |m| driver.respond_to? m }
     check_features :for => lambda { |c, f| driver.class.has_feature?(c, f) }
 
-    get route_for('/keys/new') do
+    get '/keys/new' do
       respond_to do |format|
         format.html { haml :"keys/new" }
       end

data/lib/deltacloud/collections/load_balancers.rb

@@ -60,6 +60,7 @@ module Deltacloud::Collections
       end
 
       action :register, :with_capability => :lb_register_instance do
+        param :id, :string, :required
         param :instance_id, :string,  :required
         control do
           driver.lb_register_instance(credentials, params)
@@ -73,6 +74,7 @@ module Deltacloud::Collections
       end
 
       action :unregister, :with_capability => :lb_unregister_instance do
+        param :id, :string, :required
         param :instance_id, :string,  :required
         control do
           driver.lb_unregister_instance(credentials, params)

data/lib/deltacloud/collections/storage_volumes.rb

@@ -21,7 +21,7 @@ module Deltacloud::Collections
 
     new_route_for(:storage_volumes)
 
-    get route_for("/storage_volumes/:id/attach_instance") do
+    get "/storage_volumes/:id/attach_instance" do
       @instances = driver.instances(credentials)
       respond_to do |format|
         format.html{ haml :"storage_volumes/attach"}
@@ -33,10 +33,6 @@ module Deltacloud::Collections
       standard_index_operation
       standard_show_operation
 
-      operation :show, :with_capability => :storage_volume do
-        control { show(:storage_volume) }
-      end
-
       operation :create, :with_capability => :create_storage_volume do
         param :snapshot_id, :string,  :optional
         param :capacity,    :string,  :optional
@@ -54,6 +50,7 @@ module Deltacloud::Collections
       end
 
       action :attach, :with_capability => :attach_storage_volume do
+        param :id, :string, :required
         param :instance_id,:string,  :required
         param :device,     :string,  :required
         control do
@@ -68,6 +65,7 @@ module Deltacloud::Collections
       end
 
       action :detach, :with_capability => :detach_storage_volume do
+        param :id, :string, :required
         control do
           volume = driver.storage_volume(credentials, :id => params[:id])
           @storage_volume =  driver.detach_storage_volume(credentials, :id => volume.id,

data/lib/deltacloud/core_ext.rb

@@ -19,5 +19,6 @@ require 'require_relative' if RUBY_VERSION < '1.9'
 require_relative './core_ext/array'
 require_relative './core_ext/hash'
 require_relative './core_ext/integer'
+require_relative './core_ext/ordered_hash'
 require_relative './core_ext/proc'
 require_relative './core_ext/string'

data/lib/deltacloud/core_ext/hash.rb

@@ -35,4 +35,12 @@ class Hash
     self
   end
 
+  def to_query_params
+    return '' if empty?
+    '?' + self.map do |k,v|
+      next if k.nil?
+      "#{k}=#{URI.escape(v.to_s.strip, /[^#{URI::PATTERN::UNRESERVED}]/)}"
+    end.compact.join('&')
+  end
+
 end

data/lib/deltacloud/core_ext/ordered_hash.rb

@@ -0,0 +1,222 @@
+# Code from ActiveSupport, https://github.com/rails/rails/tree/3-2-stable/activesupport
+# MIT licensed
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'yaml'
+
+YAML.add_builtin_type("omap") do |type, val|
+  OrderedHash[val.map{ |v| v.to_a.first }]
+end
+
+# The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
+# order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
+# implements a hash that preserves insertion order, as in Ruby 1.9:
+#
+#   oh = ActiveSupport::OrderedHash.new
+#   oh[:a] = 1
+#   oh[:b] = 2
+#   oh.keys # => [:a, :b], this order is guaranteed
+#
+# <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
+class OrderedHash < ::Hash
+  def to_yaml_type
+    "!tag:yaml.org,2002:omap"
+  end
+
+  def encode_with(coder)
+    coder.represent_seq '!omap', map { |k,v| { k => v } }
+  end
+
+  def to_yaml(opts = {})
+    if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
+      return super
+    end
+
+    YAML.quick_emit(self, opts) do |out|
+      out.seq(taguri) do |seq|
+        each do |k, v|
+          seq.add(k => v)
+        end
+      end
+    end
+  end
+
+  def nested_under_indifferent_access
+    self
+  end
+
+  # Returns true to make sure that this hash is extractable via <tt>Array#extract_options!</tt>
+  def extractable_options?
+    true
+  end
+
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION < '1.9'
+
+    # In MRI the Hash class is core and written in C. In particular, methods are
+    # programmed with explicit C function calls and polymorphism is not honored.
+    #
+    # For example, []= is crucial in this implementation to maintain the @keys
+    # array but hash.c invokes rb_hash_aset() originally. This prevents method
+    # reuse through inheritance and forces us to reimplement stuff.
+    #
+    # For instance, we cannot use the inherited #merge! because albeit the algorithm
+    # itself would work, our []= is not being called at all by the C code.
+
+    def initialize(*args, &block)
+      super
+      @keys = []
+    end
+
+    def self.[](*args)
+      ordered_hash = new
+
+      if (args.length == 1 && args.first.is_a?(Array))
+        args.first.each do |key_value_pair|
+          next unless (key_value_pair.is_a?(Array))
+          ordered_hash[key_value_pair[0]] = key_value_pair[1]
+        end
+
+        return ordered_hash
+      end
+
+      unless (args.size % 2 == 0)
+        raise ArgumentError.new("odd number of arguments for Hash")
+      end
+
+      args.each_with_index do |val, ind|
+        next if (ind % 2 != 0)
+        ordered_hash[val] = args[ind + 1]
+      end
+
+      ordered_hash
+    end
+
+    def initialize_copy(other)
+      super
+      # make a deep copy of keys
+      @keys = other.keys
+    end
+
+    def []=(key, value)
+      @keys << key unless has_key?(key)
+      super
+    end
+
+    def delete(key)
+      if has_key? key
+        index = @keys.index(key)
+        @keys.delete_at index
+      end
+      super
+    end
+
+    def delete_if
+      super
+      sync_keys!
+      self
+    end
+
+    def reject!
+      super
+      sync_keys!
+      self
+    end
+
+    def reject(&block)
+      dup.reject!(&block)
+    end
+
+    def keys
+      @keys.dup
+    end
+
+    def values
+      @keys.collect { |key| self[key] }
+    end
+
+    def to_hash
+      self
+    end
+
+    def to_a
+      @keys.map { |key| [ key, self[key] ] }
+    end
+
+    def each_key
+      return to_enum(:each_key) unless block_given?
+      @keys.each { |key| yield key }
+      self
+    end
+
+    def each_value
+      return to_enum(:each_value) unless block_given?
+      @keys.each { |key| yield self[key]}
+      self
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+      @keys.each {|key| yield [key, self[key]]}
+      self
+    end
+
+    def each_pair
+      return to_enum(:each_pair) unless block_given?
+      @keys.each {|key| yield key, self[key]}
+      self
+    end
+
+    alias_method :select, :find_all
+
+    def clear
+      super
+      @keys.clear
+      self
+    end
+
+    def shift
+      k = @keys.first
+      v = delete(k)
+      [k, v]
+    end
+
+    def merge!(other_hash)
+      if block_given?
+        other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+      else
+        other_hash.each { |k, v| self[k] = v }
+      end
+      self
+    end
+
+    alias_method :update, :merge!
+
+    def merge(other_hash, &block)
+      dup.merge!(other_hash, &block)
+    end
+
+    # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+    def replace(other)
+      super
+      @keys = other.keys
+      self
+    end
+
+    def invert
+      OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+    end
+
+    def inspect
+      "#<OrderedHash #{super}>"
+    end
+
+    private
+    def sync_keys!
+      @keys.delete_if {|k| !has_key?(k)}
+    end
+  end
+end

data/lib/deltacloud/core_ext/string.rb

@@ -73,6 +73,15 @@ class String
     "#{self[0..(length/2)]}#{end_string}"
   end
 
+  def remove_matrix_params
+    self.gsub(/;([^\/]*)/, '').gsub(/\?(.*)$/, '')
+  end
+
+  def convert_query_params(params={})
+    gsub(/:(\w+)/) { |p| params.delete(p[1..-1].to_sym) } +
+      params.to_query_params
+  end
+
   unless "".respond_to? :each
     alias :each :each_line
   end

data/lib/deltacloud/drivers/aruba/aruba_driver.rb

@@ -197,10 +197,6 @@ class ArubaDriver < Deltacloud::BaseDriver
     end
   end
 
-  def supported_collections
-    DEFAULT_COLLECTIONS + [ :addresses ]
-  end
-
   def configured_providers
     Deltacloud::Drivers::driver_config[:aruba][:entrypoints]["compute"].keys
   end
@@ -248,11 +244,6 @@ class ArubaDriver < Deltacloud::BaseDriver
     end
   end
 
-  def address(credentials, opts={})
-    addrs = addresses(credentials, opts)
-    filter_on(addrs, :id, opts).first
-  end
-
   def create_address(credentials, opts={})
     client = new_client(credentials)
     safely do

data/lib/deltacloud/drivers/base_driver.rb

@@ -64,10 +64,6 @@ module Deltacloud
       self.class.name.split('::').last.gsub('Driver', '').downcase
     end
 
-    def self.exceptions(&block)
-      ExceptionHandler::exceptions(&block)
-    end
-
     def self.define_hardware_profile(profile_id, &block)
       @hardware_profiles ||= []
       hw_profile = @hardware_profiles.find{|e| e.id == profile_id }
@@ -155,6 +151,23 @@ module Deltacloud
       (self.class.instance_methods - superclass_methods).include? method
     end
 
+    def supported_collections(credentials)
+      collection_arr = []
+      Deltacloud::Collections.deltacloud_modules.each do |m|
+        m.collections.each do |c|
+          # Get the required capability for the :index operation (like 'realms' or 'instance_state_machine')
+          index_operation_capability = c.operation(:index).required_capability
+          # Then use this capability to check if the 'capability' lambda defined
+          # for the Sinatra::Base class evaluate to 'true'
+          next if m.settings.respond_to?(:capability) and !m.settings.capability(index_operation_capability)
+          yield c if block_given?
+          collection_arr << c
+        end
+      end
+      collection_arr
+    end
+
+
     ## Capabilities
     # The rabbit dsl supports declaring a capability that is required
     # in the backend driver for the call to succeed. A driver can
@@ -238,6 +251,11 @@ module Deltacloud
       firewalls(credentials, opts).first if has_capability?(:firewalls)
     end
 
+    def address(credentials, opts={})
+      addresses(credentials, opts).first if has_capability?(:addresses)
+    end
+
+
     MEMBER_SHOW_METHODS = [ :realm, :image, :instance, :storage_volume, :bucket, :blob,
                             :key, :firewall ] unless defined?(MEMBER_SHOW_METHODS)
 

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

@@ -697,10 +697,6 @@ module Deltacloud
           end
         end
 
-        def address(credentials, opts={})
-          addresses(credentials, :id => opts[:id]).first
-        end
-
         def create_address(credentials, opts={})
           ec2 = new_client(credentials)
           safely do