deltacloud-core 0.0.1

data/Rakefile

@@ -0,0 +1,108 @@
+#
+# 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
+}
+
+begin
+  require 'cucumber'
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format html --out tmp/cucumber.html"
+    t.rcov = false
+  end
+
+  Cucumber::Rake::Task.new(:rcov) do |t|
+    t.cucumber_opts = "features --format pretty"
+    t.rcov = true
+    t.rcov_opts << %[-o "tmp/coverage"]
+  end
+rescue LoadError
+  desc 'Cucumber rake task not available'
+  task :features do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem'
+  end
+end
+
+
+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/converters/xml_converter.rb

@@ -0,0 +1,133 @@
+#
+# 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 Converters
+
+  ( ALIASES = {
+    :owner=>nil,
+    :volume=>:storage_volume,
+  } ) unless defined?( ALIASES )
+
+  def self.url_type(type)
+    type = type.to_sym
+    return ALIASES[type] if ( ALIASES.keys.include?( type ) )
+    type
+  end
+
+  def self.tag_name(type)
+    tag_name = type.to_s
+    tag_name.gsub( /_/, '-' )
+  end
+
+  class XMLConverter
+    def initialize(link_builder, type)
+      @link_builder = link_builder
+      @type         = type
+    end
+
+    def convert(obj, builder=nil)
+      builder ||= Builder::XmlMarkup.new( :indent=>2 )
+      if ( obj.is_a?( Array ) )
+        builder.__send__( @type.to_s.pluralize.gsub( /_/, '-' ).to_sym ) do
+          obj.each do |e|
+            convert( e, builder )
+          end
+        end
+      else
+        case ( obj )
+          when Image
+            builder.image( :href=>@link_builder.send( :image_url, obj.id ) ) {
+              builder.id( obj.id )
+              builder.owner_id( obj.owner_id )
+              builder.name( obj.name )
+              builder.description( obj.description )
+              builder.architecture( obj.architecture )
+            }
+          when Realm
+            builder.realm( :href=>@link_builder.send( :realm_url, obj.id ) ) {
+              builder.id( obj.id )
+              builder.name( obj.name )
+              builder.state( obj.state )
+              if ( obj.limit == :unlimited )
+                builder.limit()
+              else
+                builder.limit( obj.limit )
+              end
+            }
+          when Instance
+            builder.instance( :href=>@link_builder.send( :instance_url, obj.id ) ) {
+              builder.id( obj.id )
+              builder.name( obj.name )
+              builder.owner_id( obj.owner_id )
+              builder.image( :href=>@link_builder.send( :image_url, obj.image_id ) )
+              builder.__send__( 'hardware-profile', :href=>@link_builder.send( :hardware_profile_url, obj.instance_profile.name) ) do
+                builder.id( obj.instance_profile.name )
+                obj.instance_profile.overrides.each do |p, v|
+                  u = ::Deltacloud::HardwareProfile::unit(p)
+                  builder.property( :kind=>:fixed, :name=>p, :unit=>u, :value=>v )
+                end
+              end
+              builder.realm( :href=>@link_builder.send( :realm_url, obj.realm_id ) ) if obj.realm_id
+              builder.state( obj.state )
+              builder.actions {
+                if ( obj.actions )
+                  obj.actions.each do |action|
+                    builder.link( :rel=>action, :href=>@link_builder.send( "#{action}_instance_url", obj.id ) )
+                  end
+                end
+              }
+              builder.__send__( 'public-addresses' ) {
+                obj.public_addresses.each do |address|
+                  builder.address( address )
+                end
+              }
+              builder.__send__( 'private-addresses' ) {
+                obj.private_addresses.each do |address|
+                  builder.address( address )
+                end
+              }
+            }
+          when StorageVolume
+            builder.__send__('storage-volume', :href=>@link_builder.send( :storage_volume_url, obj.id )) {
+              builder.id( obj.id )
+              builder.created( obj.created )
+              builder.state( obj.state )
+              builder.capacity( obj.capacity )
+              builder.device( obj.device )
+              if ( obj.instance_id )
+                builder.instance( :href=>@link_builder.send( :instance_url, obj.instance_id ) )
+              else
+                builder.instance()
+              end
+            }
+          when StorageSnapshot
+            builder.__send__('storage-snapshot', :href=>@link_builder.send( :storage_snapshot_url, obj.id )) {
+              builder.id( obj.id )
+              builder.created( obj.created )
+              builder.state( obj.state )
+              if ( obj.storage_volume_id )
+                builder.__send__('storage-volume', :href=>@link_builder.send( :storage_volume_url, obj.storage_volume_id ) )
+              else
+                builder.__send( 'storage-volume' )
+              end
+            }
+        end
+      end
+      return builder.target!
+    end
+  end
+end

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