bbrowning-deltacloud-core 0.0.1.1

data/Rakefile

@@ -0,0 +1,85 @@
+#
+# 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
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+desc "Run basic unit tests"
+Rake::TestTask.new("test") { |t|
+  t.test_files = FileList[
+    'tests/realms_test.rb',
+    'tests/images_test.rb',
+    'tests/instances_test.rb',
+    'tests/storage_volumes_test.rb',
+    'tests/storage_snapshots_test.rb',
+  ]
+  t.verbose = false
+  t.warning = false
+}
+
+load 'deltacloud-core.gemspec'
+
+Rake::GemPackageTask.new(@spec) do |pkg|
+  pkg.need_tar = true
+end
+
+desc "Install API"
+task :install, [:install_dir, :bin_dir] do |t, args|
+
+  require 'fileutils'
+  require 'pp'
+
+  files = FileList[
+    Dir["config/**/**"],
+    Dir["features/**/**"],
+    Dir["lib/**/**"],
+    Dir["public/**/**"],
+    Dir["views/**/**"],
+    "config.ru",
+    "COPYING",
+    "README",
+    "*.rb"
+  ]
+
+  INSTALL_DIR=args.install_dir || "/usr/local/share/deltacloud-core"
+  BIN_DIR=args.bin_dir || "/usr/local/bin"
+
+  exit(1) unless FileUtils.mkdir_p(INSTALL_DIR)
+  exit(1) unless FileUtils.mkdir_p(BIN_DIR)
+
+  files.each do |f|
+    install_path = "#{INSTALL_DIR}/#{File.dirname(f)}"
+    unless File.directory?(install_path)
+      FileUtils.mkdir_p(install_path, :mode => 0755, :verbose => true)
+    end
+    next if File.directory?(f)
+    FileUtils.install(f, "#{INSTALL_DIR}/#{File.dirname(f)}", :verbose => true)
+  end
+
+  FileUtils.install('bin/deltacloudd', BIN_DIR, :verbose => true, :mode => 0755)
+end
+
+desc "Uninstall API"
+task :uninstall do
+  require 'fileutils'
+  INSTALL_DIR="/usr/share/deltacloud-core"
+  FileUtils.rm_rf(INSTALL_DIR)
+end

data/bin/deltacloudd

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'thin'
+
+options = {
+  :env => 'development'
+}
+optparse = OptionParser.new do |opts|
+
+opts.banner = <<BANNER
+Usage:
+deltacloudd -i <driver> [options]
+
+Options:
+BANNER
+  opts.on( '-i', '--driver DRIVER', 'Driver to use') do |driver|
+    ENV["API_DRIVER"] = driver
+  end
+  opts.on( '-r', '--hostname HOSTNAME',
+           'Bind to HOST address (default: localhost)') do |host|
+    ENV["API_HOST"] = host
+  end
+  opts.on( '-p', '--port PORT', 'Use PORT (default: 3001)') do |port|
+    ENV["API_PORT"] = port
+  end
+  opts.on( '-e', '--env ENV', 'Environment (default: "development")') { |env| options[:env] = env }
+  opts.on( '-h', '--help', '') { options[:help] = true }
+end
+
+optparse.parse!
+
+if options[:help]
+ puts optparse
+ exit(0)
+end
+
+unless ENV["API_DRIVER"]
+  puts "You need to specify a driver to use (-i <driver>)"
+  exit(1)
+end
+
+ENV["API_HOST"] = "localhost" unless ENV["API_HOST"]
+ENV["API_PORT"] = "3001" unless ENV["API_PORT"]
+
+dirname="#{File.dirname(__FILE__)}/.."
+
+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
+
+puts "Starting Deltacloud API :: #{ENV["API_DRIVER"]} :: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
+puts
+
+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}"
+  end
+end

data/config.ru

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

data/deltacloud.rb

@@ -0,0 +1,14 @@
+# Add ./lib into load path
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+
+require 'deltacloud/base_driver'
+require 'deltacloud/hardware_profile'
+require 'deltacloud/state_machine'
+
+require 'deltacloud/models/base_model'
+require 'deltacloud/models/realm'
+require 'deltacloud/models/image'
+require 'deltacloud/models/instance'
+require 'deltacloud/models/instance_profile'
+require 'deltacloud/models/storage_snapshot'
+require 'deltacloud/models/storage_volume'

data/lib/deltacloud/base_driver.rb

@@ -0,0 +1,19 @@
+#
+# 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
+
+require 'deltacloud/base_driver/base_driver'
+require 'deltacloud/base_driver/features'

data/lib/deltacloud/base_driver/base_driver.rb

@@ -0,0 +1,189 @@
+#
+# 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
+
+module Deltacloud
+
+  class AuthException < Exception
+  end
+
+  class BackendError < 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)
+      @hardware_profiles ||= []
+      hw_profile = @hardware_profiles.find{|e| e.name == name}
+      return if hw_profile
+      hw_profile = ::Deltacloud::HardwareProfile.new( name, &block )
+      @hardware_profiles << hw_profile
+      hw_params = hw_profile.params
+      unless hw_params.empty?
+        feature :instances, :hardware_profiles do
+          decl.operation(:create) { add_params(hw_params) }
+        end
+      end
+    end
+
+    def self.hardware_profiles
+      @hardware_profiles ||= []
+      @hardware_profiles
+    end
+
+    def hardware_profiles(credentials, opts = nil)
+      results = self.class.hardware_profiles
+      filter_hardware_profiles(results, opts)
+    end
+
+    def hardware_profile(credentials, name)
+      hardware_profiles(credentials, :name => name).first
+    end
+
+    def filter_hardware_profiles(profiles, opts)
+      if opts
+        if v = opts[:architecture]
+          profiles = profiles.select { |hwp| hwp.include?(:architecture, v) }
+        end
+        if v = opts[:name]
+          profiles = profiles.select { |hwp| hwp.name == v }
+        end
+      end
+      profiles
+    end
+
+    def find_hardware_profile(credentials, name, image_id)
+      hwp = nil
+      if name
+        unless hwp = hardware_profiles(credentials, :name => name).first
+          raise BackendError.new(400, "bad-hardware-profile-name",
+            "Hardware profile '#{name}' does not exist", nil)
+        end
+      else
+        unless image = image(credentials, :id=>image_id)
+          raise BackendError.new(400, "bad-image-id",
+              "Image with ID '#{image_id}' does not exist", nil)
+        end
+        hwp = hardware_profiles(credentials,
+                                :architecture=>image.architecture).first
+      end
+      return hwp
+    end
+
+    def self.define_instance_states(&block)
+      machine = ::Deltacloud::StateMachine.new(&block)
+      @instance_state_machine = machine
+    end
+
+    def self.instance_state_machine
+      @instance_state_machine
+    end
+
+    def instance_state_machine
+      self.class.instance_state_machine
+    end
+
+    def instance_actions_for(state)
+      actions = []
+      state_key = state.downcase.to_sym
+      states = instance_state_machine.states()
+      current_state = states.find{|e| e.name == state.underscore.to_sym }
+      if ( current_state )
+        actions = current_state.transitions.collect{|e|e.action}
+        actions.reject!{|e| e.nil?}
+      end
+      actions
+    end
+
+    def realm(credentials, opts)
+      realms = realms(credentials, opts)
+      return realms.first unless realms.empty?
+      nil
+    end
+
+    def realms(credentials, opts=nil)
+      []
+    end
+
+    def image(credentials, opts)
+      images = images(credentials, opts)
+      return images.first unless images.empty?
+      nil
+    end
+
+    def images(credentials, ops)
+      []
+    end
+
+    def instance(credentials, opts)
+      instances = instances(credentials, opts)
+      return instances.first unless instances.empty?
+      nil
+    end
+
+    def instances(credentials, ops)
+      []
+    end
+
+    def create_instance(credentials, image_id, opts)
+    end
+    def start_instance(credentials, id)
+    end
+    def stop_instance(credentials, id)
+    end
+    def reboot_instance(credentials, id)
+    end
+
+    def storage_volume(credentials, opts)
+      volumes = storage_volumes(credentials, opts)
+      return volumes.first unless volumes.empty?
+      nil
+    end
+
+    def storage_volumes(credentials, ops)
+      []
+    end
+
+    def storage_snapshot(credentials, opts)
+      snapshots = storage_snapshots(credentials, opts)
+      return snapshots.first unless snapshots.empty?
+      nil
+    end
+
+    def storage_snapshots(credentials, ops)
+      []
+    end
+
+    def filter_on(collection, attribute, opts)
+      return collection if opts.nil?
+      return collection if opts[attribute].nil?
+      filter = opts[attribute]
+      if ( filter.is_a?( Array ) )
+        return collection.select{|e| filter.include?( e.send(attribute) ) }
+      else
+        return collection.select{|e| filter == e.send(attribute) }
+      end
+    end
+  end
+
+end

data/lib/deltacloud/base_driver/features.rb

@@ -0,0 +1,159 @@
+require 'deltacloud/validation'
+
+# Add advertising of optional features to the base driver
+module Deltacloud
+
+  class FeatureError < StandardError; end
+  class DuplicateFeatureDeclError < FeatureError; end
+  class UndeclaredFeatureError < FeatureError; end
+
+  class BaseDriver
+
+    # An operation on a collection like cretae or show. Features
+    # can add parameters to operations
+    class Operation
+      attr_reader :name
+
+      include Deltacloud::Validation
+
+      def initialize(name, &block)
+        @name = name
+        @params = {}
+        instance_eval &block
+      end
+    end
+
+    # The declaration of a feature, defines what operations
+    # are modified by it
+    class FeatureDecl
+      attr_reader :name, :operations
+
+      def initialize(name, &block)
+        @name = name
+        @operations = []
+        instance_eval &block
+      end
+
+      def description(text=nil)
+        @description = text if text
+        @description
+      end
+
+      # Add a new operation or modify an existing one through BLOCK
+      def operation(name, &block)
+        unless op = @operations.find { |op| op.name == name }
+          op = Operation.new(name, &block)
+          @operations << op
+        else
+          op.instance_eval(&block) if block_given?
+        end
+        op
+      end
+    end
+
+    # A specific feature enabled by a driver (see +feature+)
+    class Feature
+      attr_reader :decl
+
+      def initialize(decl, &block)
+        @decl = decl
+        instance_eval &block if block_given?
+      end
+
+      def name
+        decl.name
+      end
+
+      def operations
+        decl.operations
+      end
+
+      def description
+        decl.description
+      end
+    end
+
+    def self.feature_decls
+      @@feature_decls ||= {}
+    end
+
+    def self.feature_decl_for(collection, name)
+      decls = feature_decls[collection]
+      if decls
+        decls.find { |dcl| dcl.name == name }
+      else
+        nil
+      end
+    end
+
+    # Declare a new feature
+    def self.declare_feature(collection, name, &block)
+      feature_decls[collection] ||= []
+      raise DuplicateFeatureDeclError if feature_decl_for(collection, name)
+      feature_decls[collection] << FeatureDecl.new(name, &block)
+    end
+
+    def self.features
+      @@features ||= {}
+    end
+
+    # Declare in a driver that it supports a specific feature
+    #
+    # The same feature can be declared multiple times in a driver, so that
+    # it can be changed successively by passing in different blocks.
+    def self.feature(collection, name, &block)
+      features[collection] ||= []
+      if f = features[collection].find { |f| f.name == name }
+        f.instance_eval(&block) if block_given?
+        return f
+      end
+      unless decl = feature_decl_for(collection, name)
+        raise UndeclaredFeatureError, "No feature #{name} for #{collection}"
+      end
+      features[collection] << Feature.new(decl, &block)
+    end
+
+    def features(collection)
+      self.class.features[collection] || []
+    end
+
+    #
+    # Declaration of optional features
+    #
+    declare_feature :instances, :user_name do
+      description "Accept a user-defined name on instance creation"
+      operation :create do
+        param :name, :string, :optional, nil,
+        "The user-defined name"
+      end
+    end
+
+    declare_feature :instances, :user_data do
+      description "Make user-defined data available on a special webserver"
+      operation :create do
+        param :user_data, :string, :optional, nil,
+        "Base64 encoded user data will be published to internal webserver"
+      end
+    end
+
+    declare_feature :instances, :authentication_key do
+      operation :create do
+        param :keyname, :string,  :optional, nil
+        "EC2 key authentification method"
+      end
+      operation :show do
+      end
+    end
+
+    declare_feature :instances, :authentication_password do
+      operation :create do
+        param :password, :string, :optional
+      end
+    end
+
+    declare_feature :instances, :hardware_profiles do
+      description "Size instances according to changes to a hardware profile"
+      # The parameters are filled in from the hardware profiles
+    end
+  end
+end