deltacloud-core 0.0.1

data/lib/deltacloud/models/storage_snapshot.rb

@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+
+class StorageSnapshot < BaseModel
+
+  attr_accessor :state
+  attr_accessor :storage_volume_id
+  attr_accessor :created
+
+end

data/lib/deltacloud/models/storage_volume.rb

@@ -0,0 +1,27 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+class StorageVolume < BaseModel
+
+  attr_accessor :created
+  attr_accessor :state
+  attr_accessor :capacity
+  attr_accessor :instance_id
+  attr_accessor :device
+
+end

data/lib/deltacloud/state_machine.rb

@@ -0,0 +1,84 @@
+
+module Deltacloud
+  class StateMachine
+
+    attr_reader :states
+    def initialize(&block)
+      @states  = []
+      instance_eval &block if block
+    end
+
+    def start()
+      state(:start)
+    end
+
+    def finish()
+      state(:finish)
+    end
+
+    def state(name)
+      state = @states.find{|e| e.name == name.to_sym}
+      if ( state.nil? )
+        state = State.new( self, name.to_sym )
+        @states << state
+      end
+      state
+    end
+
+    def method_missing(sym,*args)
+      return state( sym ) if ( args.empty? )
+      super( sym, *args )
+    end
+
+    class State
+
+      attr_reader :name
+      attr_reader :transitions
+
+      def initialize(machine, name)
+        @machine = machine
+        @name    = name
+        @transitions = []
+      end
+
+      def to_s
+        self.name.to_s
+      end
+
+      def to(destination_name)
+        destination = @machine.state(destination_name)
+        transition = Transition.new( @machine, destination )
+        @transitions << transition
+        transition
+      end
+
+    end
+
+    class Transition
+
+      attr_reader :destination
+      attr_reader :action
+
+      def initialize(machine, destination)
+        @machine = machine
+        @destination = destination
+        @auto   = false
+        @action = nil
+      end
+
+      def automatically
+        @auto = true
+      end
+
+      def automatically?
+        @auto
+      end
+
+      def on(action)
+        @action = action
+      end
+
+    end
+
+  end
+end

data/lib/deltacloud/validation.rb

@@ -0,0 +1,70 @@
+module Deltacloud::Validation
+
+  class Failure < StandardError
+    attr_reader :param
+    def initialize(param, msg='')
+      super(msg)
+      @param = param
+    end
+
+    def name
+      param.name
+    end
+  end
+
+  class Param
+    attr_reader :name, :klass, :type, :options, :description
+
+    def initialize(args)
+      @name = args[0]
+      @klass = args[1] || :string
+      @type = args[2] || :optional
+      @options = args[3] || []
+      @description = args[4] || ''
+    end
+
+    def required?
+      type.eql?(:required)
+    end
+
+    def optional?
+      type.eql?(:optional)
+    end
+  end
+
+  def param(*args)
+    raise DuplicateParamException if params[args[0]]
+    p = Param.new(args)
+    params[p.name] = p
+  end
+
+  def params
+    @params ||= {}
+    @params
+  end
+
+  # Add the parameters in hash +new+ to already existing parameters. If
+  # +new+ contains a parameter with an already existing name, the old
+  # definition is clobbered.
+  def add_params(new)
+    # We do not check for duplication on purpose: multiple calls
+    # to add_params should be cumulative
+    new.each { |p|  @params[p.name] = p }
+  end
+
+  def each_param(&block)
+    params.each_value { |p| yield p }
+  end
+
+  def validate(values)
+    each_param do |p|
+      if p.required? and not values[p.name]
+        raise Failure.new(p, "Required parameter #{p.name} not found")
+      end
+      if values[p.name] and not p.options.empty? and
+          not p.options.include?(values[p.name])
+        raise Failure.new(p, "Parameter #{p.name} has value #{values[p.name]} which is not in #{p.options.join(", ")}")
+      end
+    end
+  end
+end

data/lib/drivers.rb

@@ -0,0 +1,37 @@
+DRIVERS = {
+  :ec2 => { :name => "EC2" },
+  :rackspace => { :name => "Rackspace" },
+  :gogrid => { :name => "Gogrid" },
+  :rhevm => { :name => "RHEVM" },
+  :rimu => { :name => "Rimu", :class => "RimuHostingDriver"},
+  :opennebula => { :name => "Opennebula", :class => "OpennebulaDriver" },
+  :mock => { :name => "Mock" }
+}
+
+def driver_name
+  DRIVERS[DRIVER][:name]
+end
+
+def driver_class_name
+  basename = DRIVERS[DRIVER][:class] || "#{driver_name}Driver"
+  "Deltacloud::Drivers::#{driver_name}::#{basename}"
+end
+
+def driver_source_name
+  File.join("deltacloud", "drivers", "#{DRIVER}", "#{DRIVER}_driver.rb")
+end
+
+def driver_mock_source_name
+  return File.join('deltacloud', 'drivers', DRIVER.to_s, "#{DRIVER}_driver.rb") if driver_name.eql? 'Mock'
+  File.join('deltacloud', 'drivers', DRIVER, "#{DRIVER}_mock_driver.rb")
+end
+
+def driver
+  require driver_source_name
+
+  if Sinatra::Application.environment.eql? :test
+    require driver_mock_source_name
+  end
+
+  @driver ||= eval( driver_class_name ).new
+end

data/lib/sinatra/lazy_auth.rb

@@ -0,0 +1,56 @@
+require 'sinatra/base'
+
+# Lazy Basic HTTP authentication. Authentication is only forced when the
+# credentials are actually needed.
+module Sinatra
+  module LazyAuth
+    class LazyCredentials
+      def initialize(app)
+        @app = app
+        @provided = false
+      end
+
+      def user
+        credentials!
+        @user
+      end
+
+      def password
+        credentials!
+        @password
+      end
+
+      def provided?
+        @provided
+      end
+
+      private
+      def credentials!
+        unless provided?
+          auth = Rack::Auth::Basic::Request.new(@app.request.env)
+          unless auth.provided? && auth.basic? && auth.credentials
+            @app.authorize!
+          end
+          @user = auth.credentials[0]
+          @password = auth.credentials[1]
+          @provided = true
+        end
+      end
+
+    end
+
+    def authorize!
+      r = "#{DRIVER}-deltacloud@#{HOSTNAME}"
+      response['WWW-Authenticate'] = %(Basic realm="#{r}")
+      throw(:halt, [401, "Not authorized\n"])
+    end
+
+    # Request the current user's credentials. Actual credentials are only
+    # requested when an attempt is made to get the user name or password
+    def credentials
+      LazyCredentials.new(self)
+    end
+  end
+
+  helpers LazyAuth
+end

data/lib/sinatra/rabbit.rb

@@ -0,0 +1,272 @@
+require 'sinatra/base'
+require 'sinatra/url_for'
+require 'deltacloud/validation'
+
+module Sinatra
+
+  module Rabbit
+
+    class DuplicateParamException < Exception; end
+    class DuplicateOperationException < Exception; end
+    class DuplicateCollectionException < Exception; end
+
+    class Operation
+      attr_reader :name, :method
+
+      include ::Deltacloud::Validation
+
+      STANDARD = {
+        :index => { :method => :get, :member => false },
+        :show =>  { :method => :get, :member => true },
+        :create => { :method => :post, :member => false },
+        :update => { :method => :put, :member => true },
+        :destroy => { :method => :delete, :member => true }
+      }
+
+      def initialize(coll, name, opts, &block)
+        @name = name.to_sym
+        opts = STANDARD[@name].merge(opts) if standard?
+        @collection = coll
+        raise "No method for operation #{name}" unless opts[:method]
+        @method = opts[:method].to_sym
+        @member = opts[:member]
+        @description = ""
+        instance_eval(&block) if block_given?
+        generate_documentation
+      end
+
+      def standard?
+        STANDARD.keys.include?(name)
+      end
+
+      def description(text="")
+        return @description if text.blank?
+        @description = text
+      end
+
+      def generate_documentation
+        coll, oper = @collection, self
+        ::Sinatra::Application.get("/api/docs/#{@collection.name}/#{@name}") do
+          @collection, @operation = coll, oper
+          respond_to do |format|
+            format.html { haml :'docs/operation' }
+            format.xml { haml :'docs/operation' }
+          end
+        end
+      end
+
+      def control(&block)
+        op = self
+        @control = Proc.new do
+          op.validate(params)
+          instance_eval(&block)
+        end
+      end
+
+      def prefix
+        # FIXME: Make the /api prefix configurable
+        "/api"
+      end
+
+      def path(args = {})
+        l_prefix = args[:prefix] ? args[:prefix] : prefix
+        if @member
+          if standard?
+            "#{l_prefix}/#{@collection.name}/:id"
+          else
+            "#{l_prefix}/#{@collection.name}/:id/#{name}"
+          end
+        else
+          "#{l_prefix}/#{@collection.name}"
+        end
+      end
+
+      def generate
+        ::Sinatra::Application.send(@method, path, {}, &@control)
+        # Set up some Rails-like URL helpers
+        if name == :index
+          gen_route "#{@collection.name}_url"
+        elsif name == :show
+          gen_route "#{@collection.name.to_s.singularize}_url"
+        else
+          gen_route "#{name}_#{@collection.name.to_s.singularize}_url"
+        end
+      end
+
+      private
+      def gen_route(name)
+        route_url = path
+        if @member
+          ::Sinatra::Application.send(:define_method, name) do |id, *args|
+            url = query_url(route_url, args[0])
+            url_for url.gsub(/:id/, id.to_s), :full
+          end
+        else
+          ::Sinatra::Application.send(:define_method, name) do |*args|
+            url = query_url(route_url, args[0])
+            url_for url, :full
+          end
+        end
+      end
+    end
+
+    class Collection
+      attr_reader :name, :operations
+
+      def initialize(name, &block)
+        @name = name
+        @description = ""
+        @operations = {}
+        instance_eval(&block) if block_given?
+        generate_documentation
+      end
+
+      # Set/Return description for collection
+      # If first parameter is not present, full description will be
+      # returned.
+      def description(text='')
+        return @description if text.blank?
+        @description = text
+      end
+
+      def generate_documentation
+        coll, oper, features = self, @operations, driver.features(name)
+        ::Sinatra::Application.get("/api/docs/#{@name}") do
+          @collection, @operations, @features = coll, oper, features
+          respond_to do |format|
+            format.html { haml :'docs/collection' }
+            format.xml { haml :'docs/collection' }
+          end
+        end
+      end
+
+      # Add a new operation for this collection. For the standard REST
+      # operations :index, :show, :update, and :destroy, we already know
+      # what method to use and whether this is an operation on the URL for
+      # individual elements or for the whole collection.
+      #
+      # For non-standard operations, options must be passed:
+      #  :method : one of the HTTP methods
+      #  :member : whether this is an operation on the collection or an
+      #            individual element (FIXME: custom operations on the
+      #            collection will use a nonsensical URL) The URL for the
+      #            operation is the element URL with the name of the operation
+      #            appended
+      #
+      # This also defines a helper method like show_instance_url that returns
+      # the URL to this operation (in request context)
+      def operation(name, opts = {}, &block)
+        raise DuplicateOperationException if @operations[name]
+        @operations[name] = Operation.new(self, name, opts, &block)
+      end
+
+      def generate
+        operations.values.each { |op| op.generate }
+        app = ::Sinatra::Application
+        collname = name # Work around Ruby's weird scoping/capture
+        app.send(:define_method, "#{name.to_s.singularize}_url") do |id|
+            url_for "/api/#{collname}/#{id}", :full
+        end
+
+        if index_op = operations[:index]
+          app.send(:define_method, "#{name}_url") do
+            url_for index_op.path.gsub(/\/\?$/,''), :full
+          end
+        end
+      end
+
+      def add_feature_params(features)
+        features.each do |f|
+          f.operations.each do |fop|
+            if cop = operations[fop.name]
+              fop.params.each_key do |k|
+                if cop.params.has_key?(k)
+                  raise DuplicateParamException, "Parameter '#{k}' for operation #{fop.name} defined by collection #{@name} and by feature #{f.name}"
+                else
+                  cop.params[k] = fop.params[k]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def collections
+      @collections ||= {}
+    end
+
+    # Create a new collection. NAME should be the pluralized name of the
+    # collection.
+    #
+    # Adds a helper method #{name}_url which returns the URL to the :index
+    # operation on this collection.
+    def collection(name, &block)
+      raise DuplicateCollectionException if collections[name]
+      collections[name] = Collection.new(name, &block)
+      collections[name].add_feature_params(driver.features(name))
+      collections[name].generate
+    end
+
+    # Generate a root route for API docs
+    get '/api/docs\/?' do
+      respond_to do |format|
+        format.html { haml :'docs/index' }
+        format.xml { haml :'docs/index' }
+      end
+    end
+
+  end
+
+  module RabbitHelper
+    def query_url(url, params)
+      return url if params.nil? || params.empty?
+      url + "?#{URI.escape(params.collect{|k,v| "#{k}=#{v}"}.join('&'))}"
+    end
+
+    def entry_points
+      collections.values.inject([]) do |m, coll|
+        url = url_for coll.operations[:index].path, :full
+        m << [ coll.name, url ]
+      end
+    end
+  end
+
+  register Rabbit
+  helpers RabbitHelper
+end
+
+class String
+  # Rails defines this for a number of other classes, including Object
+  # see activesupport/lib/active_support/core_ext/object/blank.rb
+  def blank?
+      self !~ /\S/
+  end
+
+  # Title case.
+  #
+  #   "this is a string".titlecase
+  #   => "This Is A String"
+  #
+  # CREDIT: Eliazar Parra
+  # Copied from facets
+  def titlecase
+    gsub(/\b\w/){ $`[-1,1] == "'" ? $& : $&.upcase }
+  end
+
+  def pluralize
+    self + "s"
+  end
+
+  def singularize
+    self.gsub(/s$/, '')
+  end
+
+  def underscore
+      gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+  end
+end