deltacloud-core 1.0.3 → 1.0.4

data/lib/deltacloud/drivers/exceptions.rb

@@ -131,7 +131,7 @@ module Deltacloud
 
       # Condition can be class or regexp
       #
-      def match?(e)
+      def any?(e)
         @conditions.each do |c|
           return true if c.class == Class && e.class == c
           return true if c.class == Regexp && (e.class.name =~ c or e.message =~ c)
@@ -172,27 +172,44 @@ module Deltacloud
     end
 
     def self.exceptions(&block)
+      @definitions ||= []
       @definitions = Exceptions.new(&block).exception_definitions if block_given?
       @definitions
     end
 
+    module DSL
+      def exceptions(&block)
+        @definitions = Exceptions.new(&block).exception_definitions if block_given?
+        @definitions ||= []
+        @definitions
+      end
+    end
+
+    def self.logger(logger=nil)
+      @logger = logger
+      @logger ||= ::Logger.new($stderr)
+    end
+
+    def self.included(klass)
+      klass.extend(DSL)
+    end
+
     def safely(&block)
       begin
         block.call
-      rescue
-        report_method = $stderr.respond_to?(:err) ? :err : :puts
-        Deltacloud::ExceptionHandler::exceptions.each do |exdef|
-          if exdef.match?($!)
-            new_exception = exdef.handler($!)
-            m = (new_exception && !new_exception.message.nil?) ? new_exception.message : $!.message
-            unless ENV['RACK_ENV'] == 'test'
-              $stderr.send(report_method, "#{[$!.class.to_s, m].join(':')}\n#{$!.backtrace[0..10].join("\n")}")
-            end
-            raise exdef.handler($!) unless new_exception.nil?
+      rescue => e
+        log = ExceptionHandler.logger
+        self.class.exceptions.each do |definitions|
+          next unless definitions.any? e
+          if (new_exception = definitions.handler(e)) and new_exception.message
+            message = new_exception.message
           end
+          message ||= e.message
+          log.error "#{[e.class.to_s, message].join(':')}\n#{e.backtrace[0..10].join("\n")}" unless ENV['RACK_ENV'] == 'test'
+          raise definitions.handler(e) unless new_exception.nil?
         end
-        $stderr.send(report_method, "[NO HANDLED] #{[$!.class.to_s, $!.message].join(': ')}\n#{$!.backtrace.join("\n")}")
-        raise Deltacloud::ExceptionHandler::BackendError.new($!, "Unhandled exception or status code (#{$!.message})")
+        log.error "[NO HANDLED] #{[e.class.to_s, e.message].join(': ')}\n#{e.backtrace.join("\n")}" unless ENV['RACK_ENV'] == 'test'
+        raise BackendError.new(e, "Unhandled exception or status code (#{e.message})")
       end
     end
 

data/lib/deltacloud/drivers/features.rb

@@ -65,6 +65,13 @@ module Deltacloud
         end
       end
 
+      feature :realm_filter, :for => :instances do
+        description "Filter instances by realm"
+        operation :index do
+          param :realm_id, :string, :optional
+        end
+      end
+
       feature :user_name, :for => :instances do
         description "Allow to set user-defined name for the instance"
         operation :create do

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

@@ -25,11 +25,7 @@ module Deltacloud
     module Fgcp
 class FgcpDriver < Deltacloud::BaseDriver
 
-  CERT_DIR = ENV['FGCP_CERT_DIR'] || File::expand_path('~/.deltacloud/config/fgcp')
-
-  def supported_collections
-    DEFAULT_COLLECTIONS + [ :addresses, :load_balancers, :firewalls ]
-  end
+  CERT_DIR = ENV['FGCP_CERT_DIR'] || File::expand_path('~/.deltacloud/drivers/fgcp')
 
   feature :instances, :user_name
   feature :instances, :metrics
@@ -678,10 +674,6 @@ class FgcpDriver < Deltacloud::BaseDriver
     addresses
   end
 
-  def address(credentials, opts={})
-    addresses(credentials, opts).first
-  end
-
   def create_address(credentials, opts={})
     safely do
       client = new_client(credentials)

data/lib/deltacloud/drivers/google/google_driver.rb

@@ -202,6 +202,19 @@ class GoogleDriver < Deltacloud::BaseDriver
     return true
   end
 
+  exceptions do
+
+    on /(InvalidAccessKeyId|InvalidSecurity)/ do
+      status 401
+    end
+
+    on /BucketNameUnavailable/ do
+      message "Bucket name already taken"
+      status 409
+    end
+
+  end
+
   private
 
   def new_client(credentials)

data/lib/deltacloud/drivers/mock/data/addresses/192.168.0.1.yml

@@ -0,0 +1,3 @@
+---
+:id: 192.168.0.1
+:instance_id: 

data/lib/deltacloud/drivers/mock/data/addresses/192.168.0.2.yml

@@ -0,0 +1,3 @@
+---
+:id: 192.168.0.2
+:instance_id: 

data/lib/deltacloud/drivers/mock/data/addresses/192.168.0.3.yml

@@ -0,0 +1,3 @@
+---
+:id: "192.168.0.3"
+:instance_id:

data/lib/deltacloud/drivers/mock/data/addresses/192.168.0.4.yml

@@ -0,0 +1,3 @@
+---
+:id: "192.168.0.4"
+:instance_id:

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

@@ -17,6 +17,7 @@
 require 'yaml'
 require 'base64'
 require 'etc'
+require 'ipaddr'
 
 require_relative 'mock_client'
 require_relative 'mock_driver_cimi_methods'
@@ -79,6 +80,7 @@ module Deltacloud::Drivers::Mock
     feature :instances, :user_data
     feature :instances, :authentication_key
     feature :instances, :metrics
+    feature :instances, :realm_filter
     feature :images, :user_name
     feature :images, :user_description
 
@@ -161,12 +163,13 @@ module Deltacloud::Drivers::Mock
       end
     end
 
-    def instances(credentials, opts=nil)
+    def instances(credentials, opts={})
       check_credentials( credentials )
       instances = @client.build_all(Instance)
       instances = filter_on( instances, :owner_id, :owner_id => credentials.user )
       instances = filter_on( instances, :id, opts )
       instances = filter_on( instances, :state, opts )
+      instances = filter_on( instances, :realm_id, opts)
       instances
     end
 
@@ -333,6 +336,48 @@ module Deltacloud::Drivers::Mock
       @client.destroy(:keys, key.id)
     end
 
+    def addresses(credentials, opts={})
+      check_credentials(credentials)
+      addresses = @client.build_all(Address)
+      addresses = filter_on( addresses, :id, opts )
+    end
+
+    def create_address(credentials, opts={})
+      check_credentials(credentials)
+      address = {:id => allocate_mock_address.to_s, :instance_id=>nil}
+      @client.store(:addresses, address)
+      Address.new(address)
+    end
+
+    def destroy_address(credentials, opts={})
+      check_credentials(credentials)
+      address = @client.load(:addresses, opts[:id])
+      raise "AddressInUse" unless address[:instance_id].nil?
+      @client.destroy(:addresses, opts[:id])
+    end
+
+    def associate_address(credentials, opts={})
+      check_credentials(credentials)
+      address = @client.load(:addresses, opts[:id])
+      raise "AddressInUse" unless address[:instance_id].nil?
+      instance = @client.load(:instances, opts[:instance_id])
+      address[:instance_id] = instance[:id]
+      instance[:public_addresses] = [InstanceAddress.new(address[:id])]
+      @client.store(:addresses, address)
+      @client.store(:instances, instance)
+    end
+
+    def disassociate_address(credentials, opts={})
+      check_credentials(credentials)
+      address = @client.load(:addresses, opts[:id])
+      raise "AddressNotInUse" unless address[:instance_id]
+      instance = @client.load(:instances, address[:instance_id])
+      address[:instance_id] = nil
+      instance[:public_addresses] = [InstanceAddress.new("#{instance[:image_id]}.#{instance[:id]}.public.com", :type => :hostname)]
+      @client.store(:addresses, address)
+      @client.store(:instances, instance)
+    end
+
     #--
     # Buckets
     #--
@@ -530,6 +575,17 @@ module Deltacloud::Drivers::Mock
       end
     end
 
+    #Mock allocation of 'new' address
+    #There is a synchronization problem (but it's the mock driver,
+    #mutex seemed overkill)
+    def allocate_mock_address
+      addresses = []
+      @client.members(:addresses).each do |addr|
+        addresses << IPAddr.new("#{addr}").to_i
+      end
+      IPAddr.new(addresses.sort.pop+1, Socket::AF_INET)
+    end
+
     def attach_volume_instance(volume_id, device, instance_id)
       volume = @client.load(:storage_volumes, volume_id)
       instance = @client.load(:instances, instance_id)
@@ -597,6 +653,14 @@ module Deltacloud::Drivers::Mock
         message "Key with same name already exists"
       end
 
+      on /AddressInUse/ do
+        status 403
+      end
+
+      on /AddressNotInUse/ do
+        status 403
+      end
+
       on /BucketNotExist/ do
         status 404
       end

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

@@ -20,7 +20,6 @@
 module Deltacloud::Drivers::Mock
 
   class MockDriver < Deltacloud::BaseDriver
-
     def networks(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
@@ -54,58 +53,69 @@ module Deltacloud::Drivers::Mock
       end
     end
 
-    def routing_groups(credentials, opts={})
+    def forwarding_groups(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
-        routing_groups = @client.load_all_cimi(:routing_group).map{|rg| CIMI::Model::RoutingGroup.from_json(rg)}
-        routing_groups.map{|rg|convert_cimi_mock_urls(:routing_group, rg, opts[:env])}.flatten
+        forwarding_groups = @client.load_all_cimi(:forwarding_group).map{|fg| CIMI::Model::ForwardingGroup.from_json(fg)}
+        forwarding_groups.map{|fg|convert_cimi_mock_urls(:forwarding_group, fg, opts[:env])}.flatten
       else
-        routing_group = CIMI::Model::RoutingGroup.from_json(@client.load_cimi(:routing_group, opts[:id]))
-        convert_cimi_mock_urls(:routing_group, routing_group, opts[:env])
+        forwarding_group = CIMI::Model::ForwardingGroup.from_json(@client.load_cimi(:forwarding_group, opts[:id]))
+        convert_cimi_mock_urls(:forwarding_group, forwarding_group, opts[:env])
       end
     end
 
-    def routing_group_templates(credentials, opts={})
+    def forwarding_group_templates(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
-        routing_group_templates = @client.load_all_cimi(:routing_group_template).map{|rg_templ| CIMI::Model::RoutingGroupTemplate.from_json(rg_templ)}
-        routing_group_templates.map{|rg_templ|convert_cimi_mock_urls(:routing_group_template, rg_templ, opts[:env])}.flatten
+        forwarding_group_templates = @client.load_all_cimi(:forwarding_group_template).map{|fg_templ| CIMI::Model::ForwardingGroupTemplate.from_json(fg_templ)}
+        forwarding_group_templates.map{|fg_templ|convert_cimi_mock_urls(:forwarding_group_template, fg_templ, opts[:env])}.flatten
       else
-        routing_group_template = CIMI::Model::RoutingGroupTemplate.from_json(@client.load_cimi(:routing_group_template, opts[:id]))
-        convert_cimi_mock_urls(:routing_group_template, routing_group_template, opts[:env])
+        forwarding_group_template = CIMI::Model::ForwardingGroupTemplate.from_json(@client.load_cimi(:forwarding_group_template, opts[:id]))
+        convert_cimi_mock_urls(:forwarding_group_template, forwarding_group_template, opts[:env])
       end
     end
 
-    def vsps(credentials, opts={})
+    def network_ports(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
-        vsps = @client.load_all_cimi(:vsp).map{|vsp| CIMI::Model::VSP.from_json(vsp)}
-        vsps.map{|vsp|convert_cimi_mock_urls(:vsp, vsp, opts[:env])}.flatten
+        ports = @client.load_all_cimi(:network_port).map{|net_port| CIMI::Model::NetworkPort.from_json(net_port)}
+        ports.map{|net_port|convert_cimi_mock_urls(:network_port, net_port, opts[:env])}.flatten
       else
-        vsp = CIMI::Model::VSP.from_json(@client.load_cimi(:vsp, opts[:id]))
-        convert_cimi_mock_urls(:vsp, vsp, opts[:env])
+        port = CIMI::Model::NetworkPort.from_json(@client.load_cimi(:network_port, opts[:id]))
+        convert_cimi_mock_urls(:network_port, port, opts[:env])
       end
     end
 
-    def vsp_configurations(credentials, opts={})
+    def network_port_configurations(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
-        vsp_configurations = @client.load_all_cimi(:vsp_configuration).map{|vsp_config| CIMI::Model::VSPConfiguration.from_json(vsp_config)}
-        vsp_configurations.map{|vsp_config|convert_cimi_mock_urls(:vsp_configuration, vsp_config, opts[:env])}.flatten
+        network_port_configurations = @client.load_all_cimi(:network_port_configuration).map{|network_port_config| CIMI::Model::NetworkPortConfiguration.from_json(network_port_config)}
+        network_port_configurations.map{|network_port_config|convert_cimi_mock_urls(:network_port_configuration, network_port_config, opts[:env])}.flatten
       else
-        vsp_configuration = CIMI::Model::VSPConfiguration.from_json(@client.load_cimi(:vsp_configuration, opts[:id]))
-        convert_cimi_mock_urls(:vsp_configuration, vsp_configuration, opts[:env])
+        network_port_configuration = CIMI::Model::NetworkPortConfiguration.from_json(@client.load_cimi(:network_port_configuration, opts[:id]))
+        convert_cimi_mock_urls(:network_port_configuration, network_port_configuration, opts[:env])
       end
     end
 
-    def vsp_templates(credentials, opts={})
+    def network_port_templates(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
-        vsp_templates = @client.load_all_cimi(:vsp_template).map{|vsp_templ| CIMI::Model::VSPTemplate.from_json(vsp_templ)}
-        vsp_templates.map{|vsp_templ|convert_cimi_mock_urls(:vsp_template, vsp_templ, opts[:env])}.flatten
+        network_port_templates = @client.load_all_cimi(:network_port_template).map{|net_port_templ| CIMI::Model::NetworkPortTemplate.from_json(net_port_templ)}
+        network_port_templates.map{|net_port_templ|convert_cimi_mock_urls(:network_port_template, net_port_templ, opts[:env])}.flatten
       else
-        vsp_template = CIMI::Model::VSPTemplate.from_json(@client.load_cimi(:vsp_template, opts[:id]))
-        convert_cimi_mock_urls(:vsp_template, vsp_template, opts[:env])
+        network_port_template = CIMI::Model::NetworkPortTemplate.from_json(@client.load_cimi(:network_port_template, opts[:id]))
+        convert_cimi_mock_urls(:network_port_template, network_port_template, opts[:env])
+      end
+    end
+
+    def address_templates(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        address_templates = @client.load_all_cimi(:address_template).map{|addr_templ| CIMI::Model::AddressTemplate.from_json(addr_templ)}
+        address_templates.map{|addr_templ|convert_cimi_mock_urls(:address_template, addr_templ, opts[:env])}.flatten
+      else
+        address_template = CIMI::Model::AddressTemplate.from_json(@client.load_cimi(:address_template, opts[:id]))
+        convert_cimi_mock_urls(:address_template, address_template, opts[:env])
       end
     end
 
@@ -120,7 +130,11 @@ module Deltacloud::Drivers::Mock
                 convert_struct_urls(item, k.to_s.singularize.to_sym, context)
               end
             else
-              convert_struct_urls(v, k, context)
+              opts = nil
+              if is_subcollection?(v, cimi_object.id)
+                opts = {:parent_model_name => model_name, :parent_item_name => cimi_object.name}
+              end
+              convert_struct_urls(v, k, context, opts)
             end
         end
       end
@@ -130,13 +144,22 @@ module Deltacloud::Drivers::Mock
       cimi_object
     end
 
-    def convert_struct_urls(struct, cimi_name, context)
+    def is_subcollection?(struct, cimi_object_id)
+      return false if struct.href.nil?
+      struct.href.include?(cimi_object_id)
+    end
+
+    def convert_struct_urls(struct, cimi_name, context, opts = nil)
       return unless (struct.respond_to?(:href) && (not struct.href.nil?) && (not cimi_name == :operation ))
-      obj_name = struct.href.split("/").last
-      if cimi_name.to_s.end_with?("config")
-        struct.href = context.send(:"#{cimi_name}uration_url", obj_name)
+      if opts
+        struct.href = context.send(:"#{opts[:parent_model_name]}_url", opts[:parent_item_name]) + "/#{cimi_name}"
       else
-        struct.href = context.send(:"#{cimi_name}_url", obj_name)
+        obj_name = struct.href.split("/").last
+        if cimi_name.to_s.end_with?("config")
+          struct.href = context.send(:"#{cimi_name}uration_url", obj_name)
+        else
+          struct.href = context.send(:"#{cimi_name}_url", obj_name)
+        end
       end
     end
 

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

@@ -40,6 +40,17 @@ module Deltacloud
 
         define_hardware_profile('default')
 
+        def supported_collections(credentials)
+          #get the collections as defined by 'capability' and 'respond_to?' blocks
+          super_collections = super
+          begin
+             client = new_client(credentials, :buckets)
+          rescue Deltacloud::ExceptionHandler::NotImplemented #OpenStack::Exception::NotImplemented...
+             return super_collections - [Sinatra::Rabbit::BucketsCollection]
+          end
+          super_collections
+        end
+
         def hardware_profiles(credentials, opts = {})
           os = new_client(credentials)
           results = []
@@ -333,6 +344,9 @@ private
         #for v2 authentication credentials.name == "username+tenant_name"
         def new_client(credentials, type = :compute)
           tokens = credentials.user.split("+")
+          if credentials.user.empty?
+            raise AuthenticationFailure.new(Exception.new("Error: you must supply the username"))
+          end
           if (tokens.size != 2 && api_v2)
             raise ValidationFailure.new(Exception.new("Error: expected \"username+tenantname\" as username, you provided: #{credentials.user}"))
           else
@@ -351,12 +365,6 @@ private
           end
         end
 
-        def cloudfiles_client(credentials)
-          safely do
-            CloudFiles::Connection.new(:username => credentials.user, :api_key => credentials.password)
-          end
-        end
-
 #NOTE: for the convert_from_foo methods below... openstack-compute
 #gives Hash for 'flavors' but OpenStack::Compute::Flavor for 'flavor'
 #hence the use of 'send' to deal with both cases and save duplication
@@ -500,6 +508,10 @@ private
             status 400
           end
 
+          on /Must supply a :username/ do
+            status 401
+          end
+
           on /OpenStack::Exception::Authentication/ do
             status 401
           end