deltacloud-core 1.1.1 → 1.1.2

data/lib/deltacloud/helpers/collection_helper.rb

@@ -0,0 +1,106 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+module Deltacloud
+
+  # Collection methods that every frontend need to provide.
+  #
+  module CollectionMethods
+
+    # Return all collections provided by the current frontend
+    #
+    def collections
+      module_klass::Collections.collections
+    end
+
+    # Return all collection names provided by the current frontend
+    #
+    def collection_names
+      module_klass::Collections.collection_names
+    end
+
+    # Simple check if the collection is available in the current frontend
+    #
+    def collection_exists?(c)
+      collections.include? c
+    end
+
+    private
+
+    def module_klass
+      @klass ||= self
+    end
+
+  end
+
+  extend CollectionMethods
+
+  module CollectionHelper
+
+    def collection_names
+      collections.map { |c| c.collection_name }
+    end
+
+    def collections
+      @collections ||= []
+    end
+
+    def collection(name)
+      collections.find { |c| c.collection_name == name }
+    end
+
+
+    def modules(frontend)
+      case frontend
+        when :cimi then @cimi_modules ||= []
+        when :deltacloud then @deltacloud_modules ||= []
+      end
+    end
+
+    # This method will load all collections from given directory.
+    #
+    # Syntax:
+    #
+    # load_collections_for :cimi, :from => DIRECTORY
+    #
+    def load_collections_for(frontend, opts={})
+      frontend_module = (frontend == :cimi) ? CIMI : Deltacloud
+      Dir[File.join(opts[:from], '*.rb')].each do |collection|
+        base_collection_name = File.basename(collection).gsub('.rb', '')
+        next if base_collection_name == 'base'
+        require collection
+        collection_module_class = frontend_module::Collections.const_get(
+          base_collection_name.camelize
+        )
+        modules(frontend) << collection_module_class
+        if collection_module_class.collections.nil?
+          warn "WARNING: #{collection_module_class} does not include any collections"
+        else
+          collection_module_class.collections.each do |c|
+            if frontend_module.collection_exists?(c)
+              raise "ERROR: Collection already registred #{c}"
+            end
+            frontend_module.collections << c
+          end
+        end
+      end
+    end
+
+  end
+end
+
+module CIMI
+  extend Deltacloud::CollectionMethods
+end

data/lib/deltacloud/helpers/deltacloud_helper.rb

@@ -18,6 +18,10 @@ module Deltacloud::Helpers
 
     require 'benchmark'
 
+    def current_provider
+      Thread.current[:provider] || ENV['API_PROVIDER'] || 'default'
+    end
+
     def collections_to_json(collections)
       r = {
         :version => settings.version,
@@ -53,12 +57,12 @@ module Deltacloud::Helpers
     end
 
     def instance_action_method(action)
-      action_method(action, Sinatra::Rabbit::InstancesCollection)
+      action_method(action, Deltacloud::Rabbit::InstancesCollection)
     end
 
     def action_method(action, collection)
       http_method = collection.operation(action).http_method
-      http_method || Sinatra::Rabbit::BaseCollection.http_method_for(action)
+      http_method || Deltacloud::Rabbit::BaseCollection.http_method_for(action)
     end
 
     def filter_all(model)
@@ -76,7 +80,7 @@ module Deltacloud::Helpers
           format.json { JSON::dump({ model => @elements.map { |el| el.to_hash(self) }}) }
         end
       else
-        report_error(@exception.respond_to?(:code) ? @exception.code : 500)
+        report_error(@exception.respond_to?(:code) ? @exception.code : nil)
       end
     end
 
@@ -102,10 +106,10 @@ module Deltacloud::Helpers
       Deltacloud::Exceptions.logger(Deltacloud.default_frontend.logger)
     end
 
-    def report_error(code=nil)
+    def report_error(code=nil, message=nil)
 
       if !code.nil?
-        @error = Deltacloud::Exceptions.exception_from_status(code, translate_error_code(code)[:message])
+        @error = Deltacloud::Exceptions.exception_from_status(code, message || translate_error_code(code)[:message])
         @code = code
         message = @error.message
       else
@@ -124,16 +128,16 @@ module Deltacloud::Helpers
       end
 
       respond_to do |format|
-        format.xml {  haml :"errors/#{@code || @error.code}", :layout => false }
+        format.xml {  haml :"errors/common", :layout => false }
         format.json { JSON::dump({ :code => @code || @error.code, :message => message, :error => @error.class.name }) }
         format.html {
           begin
-            haml :"errors/#{@code || @error.code}", :layout => :error
+            haml :"errors/common", :layout => :error
           rescue RuntimeError
             # If the HTML representation of error is missing, then try to report
             # it through XML
             @media_type=:xml
-            haml :"errors/#{@code || @error.code}", :layout => false
+            haml :"errors/common", :layout => false
           end
         }
       end

data/lib/deltacloud/models/address.rb

@@ -14,25 +14,27 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class Address < BaseModel
-  attr_accessor :instance_id
+module Deltacloud
+  class Address < BaseModel
+    attr_accessor :instance_id
 
-  def initialize(init=nil)
-    super(init)
-  end
+    def initialize(init=nil)
+      super(init)
+    end
 
-  def associated?
-    !self.instance_id.nil?
-  end
+    def associated?
+      !self.instance_id.nil?
+    end
 
-  def to_hash(context)
-    r = {
-      :id => self.id,
-      :href => context.address_url(self.id),
-      :associated => associated?
-    }
-    r[:instance_id] = instance_id if associated?
-    r
-  end
+    def to_hash(context)
+      r = {
+        :id => self.id,
+        :href => context.address_url(self.id),
+        :associated => associated?
+      }
+      r[:instance_id] = instance_id if associated?
+      r
+    end
 
+  end
 end

data/lib/deltacloud/models/base_model.rb

@@ -14,38 +14,41 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+module Deltacloud
+  class BaseModel
+
+    attr_accessor :name, :description
+
+    def initialize(init=nil)
+      if ( init )
+        @id=init[:id]
+        init.each{|k,v|
+          self.send( "#{k}=", v ) if ( self.respond_to?( "#{k}=" ) )
+        }
+      end
+    end
 
-class BaseModel
-
-  def initialize(init=nil)
-    if ( init )
-      @id=init[:id]
-      init.each{|k,v|
-        self.send( "#{k}=", v ) if ( self.respond_to?( "#{k}=" ) )
-      }
+    def self.attr_accessor(*vars)
+      @attributes ||= [:id]
+      @attributes.concat vars
+      super
     end
-  end
 
-  def self.attr_accessor(*vars)
-    @attributes ||= [:id]
-    @attributes.concat vars
-    super
-  end
+    def self.attributes
+      @attributes
+    end
 
-  def self.attributes
-    @attributes
-  end
+    def attributes
+      self.class.attributes
+    end
 
-  def attributes
-    self.class.attributes
-  end
+    def id
+      @id
+    end
 
-  def id
-    @id
-  end
+    def to_entity
+      self.class.name.downcase
+    end
 
-  def to_entity
-    self.class.name.downcase
   end
-
 end

data/lib/deltacloud/models/blob.rb

@@ -14,27 +14,29 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class Blob < BaseModel
+module Deltacloud
+  class Blob < BaseModel
 
-  #already has an id from basemodel (for the key)
-  attr_accessor :bucket
-  attr_accessor :content_length
-  attr_accessor :content_type
-  attr_accessor :last_modified
-  attr_accessor :content
-  attr_accessor :user_metadata
+    #already has an id from basemodel (for the key)
+    attr_accessor :bucket
+    attr_accessor :content_length
+    attr_accessor :content_type
+    attr_accessor :last_modified
+    attr_accessor :content
+    attr_accessor :user_metadata
 
-  def to_hash(context)
-    {
-      :id => self.id,
-      :href => context.bucket_url(bucket) + '/' + self.id,
-      :bucket => { :rel => :bucket, :href => context.bucket_url(bucket), :id => bucket },
-      :content_length => content_length,
-      :content_type => content_type,
-      :last_modified => last_modified,
-      :content => content,
-      :user_metadata => user_metadata
-    }
-  end
+    def to_hash(context)
+      {
+        :id => self.id,
+        :href => context.bucket_url(bucket) + '/' + self.id,
+        :bucket => { :rel => :bucket, :href => context.bucket_url(bucket), :id => bucket },
+        :content_length => content_length,
+        :content_type => content_type,
+        :last_modified => last_modified,
+        :content => content,
+        :user_metadata => user_metadata
+      }
+    end
 
+  end
 end

data/lib/deltacloud/models/bucket.rb

@@ -14,24 +14,29 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class Bucket < BaseModel
+module Deltacloud
+  class Bucket < BaseModel
 
-  attr_accessor :name
-  attr_accessor :size
-  attr_accessor :blob_list
+    attr_accessor :name
+    attr_accessor :size
+    attr_accessor :blob_list
 
-  def blob_list
-    @blob_list || []
-  end
+    def blob_list
+      @blob_list || []
+    end
 
-  def to_hash(context)
-    {
-      :id => self.id,
-      :href => context.bucket_url(self.id),
-      :name => name,
-      :size => size,
-      :blob_list => blob_list.map { |b| { :rel => :blob, :href => context.url("/buckets/#{self.id}/#{b}"), :id => b }}
-    }
-  end
+    def to_hash(context)
+      {
+        :id => self.id,
+        :href => context.bucket_url(self.id),
+        :name => name,
+        :size => size,
+        :blob_list => blob_list.map { |b| {
+          :rel => :blob,
+          :href => context.url("/buckets/#{self.id}/#{b}"), :id => b }
+        }
+      }
+    end
 
+  end
 end

data/lib/deltacloud/models/firewall.rb

@@ -14,22 +14,24 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class Firewall < BaseModel
-  attr_accessor :name
-  attr_accessor :description
-  attr_accessor :owner_id
-  attr_accessor :rules
+module Deltacloud
+  class Firewall < BaseModel
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :owner_id
+    attr_accessor :rules
 
-  def to_hash(context)
-    r = {
-      :id => self.id,
-      :href => context.firewall_url(self.id),
-      :name => name,
-      :description => description,
-      :owner_id => owner_id,
-      :rules => []
-    }
-    r[:rules] = rules.map { |rule| rule.to_hash(context) } if rules and !rules.empty?
-    r
+    def to_hash(context)
+      r = {
+        :id => self.id,
+        :href => context.firewall_url(self.id),
+        :name => name,
+        :description => description,
+        :owner_id => owner_id,
+        :rules => []
+      }
+      r[:rules] = rules.map { |rule| rule.to_hash(context) } if rules and !rules.empty?
+      r
+    end
   end
 end

data/lib/deltacloud/models/firewall_rule.rb

@@ -14,26 +14,28 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class FirewallRule < BaseModel
-  attr_accessor :allow_protocol # tcp/udp/icmp
-  attr_accessor :port_from
-  attr_accessor :port_to
-  attr_accessor :sources
-  attr_accessor :direction #ingress egress
-  attr_accessor :rule_action #Accept/Deny - initially added for FGCP
-  attr_accessor :log_rule #log when rule triggered true/false - added for FGCP
+module Deltacloud
+  class FirewallRule < BaseModel
+    attr_accessor :allow_protocol # tcp/udp/icmp
+    attr_accessor :port_from
+    attr_accessor :port_to
+    attr_accessor :sources
+    attr_accessor :direction #ingress egress
+    attr_accessor :rule_action #Accept/Deny - initially added for FGCP
+    attr_accessor :log_rule #log when rule triggered true/false - added for FGCP
 
-  def to_hash(context)
-    {
-      :id => self.id,
-      :allow_protocol => allow_protocol,
-      :port_from => port_from,
-      :port_to => port_to,
-      :sources => sources,
-      :direction => direction,
-      :rule_action => rule_action,
-      :log_rule => log_rule
-    }.delete_if { |k, v| v.nil? }
-  end
+    def to_hash(context)
+      {
+        :id => self.id,
+        :allow_protocol => allow_protocol,
+        :port_from => port_from,
+        :port_to => port_to,
+        :sources => sources,
+        :direction => direction,
+        :rule_action => rule_action,
+        :log_rule => log_rule
+      }.delete_if { |k, v| v.nil? }
+    end
 
+  end
 end