bbrowning-deltacloud-core 0.0.4-java

data/server.rb

@@ -0,0 +1,354 @@
+require 'sinatra'
+require 'deltacloud'
+require 'drivers'
+require 'json'
+require 'sinatra/respond_to'
+require 'sinatra/static_assets'
+require 'sinatra/rabbit'
+require 'sinatra/lazy_auth'
+require 'erb'
+require 'haml'
+require 'open3'
+
+configure do
+  set :raise_errors => false
+  set :show_exceptions, false
+end
+
+configure :development do
+  # So we can just use puts for logging
+  $stdout.sync = true
+  $stderr.sync = true
+end
+
+# You could use $API_HOST environment variable to change your hostname to
+# whatever you want (eg. if you running API behind NAT)
+HOSTNAME=ENV['API_HOST'] ? ENV['API_HOST'] : nil
+
+error Deltacloud::Validation::Failure do
+  report_error(400, "validation_failure")
+end
+
+error Deltacloud::AuthException do
+  report_error(403, "auth_exception")
+end
+
+error Deltacloud::BackendError do
+  report_error(500, "backend_error")
+end
+
+# Redirect to /api
+get '/' do redirect url_for('/api'); end
+
+get '/api\/?' do
+    @version = 0.1
+    respond_to do |format|
+        format.xml { haml :"api/show" }
+        format.json do
+          { :api => {
+            :version => @version,
+            :driver => DRIVER,
+            :links => entry_points.collect { |l| { :rel => l[0], :href => l[1]} }
+            }
+          }.to_json
+        end
+        format.html { haml :"api/show" }
+    end
+end
+
+# Rabbit DSL
+
+collection :realms do
+  description <<END
+  Within a cloud provider a realm represents a boundary containing resources.
+  The exact definition of a realm is left to the cloud provider.
+  In some cases, a realm may represent different datacenters, different continents,
+  or different pools of resources within a single datacenter.
+  A cloud provider may insist that resources must all exist within a single realm in
+  order to cooperate. For instance, storage volumes may only be allowed to be mounted to
+  instances within the same realm.
+END
+
+  operation :index do
+    description <<END
+    Operation will list all available realms. For specific architecture use "architecture" parameter.
+END
+    param :id,            :string
+    param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
+    control { filter_all(:realms) }
+  end
+
+  #FIXME: It always shows whole list
+  operation :show do
+    description 'Show an realm identified by "id" parameter.'
+    param :id,           :string, :required
+    control { show(:realm) }
+  end
+
+end
+
+collection :images do
+  description <<END
+  An image is a platonic form of a machine. Images are not directly executable,
+  but are a template for creating actual instances of machines."
+END
+
+  operation :index do
+    description <<END
+    The instances collection will return a set of all images
+    available to the current use. You can filter images using
+    "owner_id" and "architecture" parameter
+END
+    param :id,            :string
+    param :architecture,  :string,  :optional
+    control { filter_all(:images) }
+  end
+
+  operation :show do
+    description 'Show an image identified by "id" parameter.'
+    param :id,           :string, :required
+    control { show(:image) }
+  end
+
+end
+
+collection :instance_states do
+  description "The possible states of an instance, and how to traverse between them "
+
+  operation :index do
+    control do
+      @machine = driver.instance_state_machine
+      respond_to do |format|
+        format.xml { haml :'instance_states/show', :layout => false }
+        format.json do
+          out = []
+          @machine.states.each do |state|
+            transitions = state.transitions.collect do |t|
+              t.automatically? ? {:to => t.destination, :auto => 'true'} : {:to => t.destination, :action => t.action}
+            end
+            out << { :name => state, :transitions => transitions }
+          end
+          out.to_json
+        end
+        format.html { haml :'instance_states/show'}
+        format.gv { erb :"instance_states/show" }
+        format.png do
+          # Trick respond_to into looking up the right template for the
+          # graphviz file
+          format(:gv); gv = erb :"instance_states/show"; format(:png)
+          png =  ''
+          cmd = 'dot -Kdot -Gpad="0.2,0.2" -Gsize="5.0,8.0" -Gdpi="180" -Tpng'
+          Open3.popen3( cmd ) do |stdin, stdout, stderr|
+            stdin.write( gv )
+            stdin.close()
+            png = stdout.read
+          end
+          png
+        end
+      end
+    end
+  end
+end
+
+get "/api/instances/new" do
+  @instance = Instance.new( { :id=>params[:id], :image_id=>params[:image_id] } )
+  @image   = driver.image( credentials, :id => params[:image_id] )
+  @hardware_profiles = driver.hardware_profiles(credentials, :architecture => @image.architecture )
+  @realms = driver.realms(credentials)
+  respond_to do |format|
+    format.html { haml :"instances/new" }
+  end
+end
+
+collection :instances do
+  description <<END
+  An instance is a concrete machine realized from an image.
+  The images collection may be obtained by following the link from the primary entry-point."
+END
+
+  operation :index do
+    description "List all instances"
+    param :id,            :string,  :optional
+    param :state,         :string,  :optional
+    control { filter_all(:instances) }
+  end
+
+  operation :show do
+    description 'Show an instance identified by "id" parameter.'
+    param :id,           :string, :required
+    control { show(:instance) }
+  end
+
+  operation :create do
+    description "Create a new instance"
+    param :image_id,     :string, :required
+    param :realm_id,     :string, :optional
+    param :hwp_id,       :string, :optional
+    control do
+      @image = driver.image(credentials, :id => params[:image_id])
+      instance = driver.create_instance(credentials, @image.id, params)
+      respond_to do |format|
+        format.xml do
+          response.status = 201  # Created
+          response['Location'] = instance_url(instance.id)
+          @instance = instance
+          haml :"instances/show"
+        end
+        format.html do
+          redirect instance_url(instance.id) if instance and instance.id
+          redirect instances_url
+        end
+      end
+    end
+  end
+
+  operation :reboot, :method => :post, :member => true do
+    description "Reboot running instance"
+    param :id,           :string, :required
+    control { instance_action(:reboot) }
+  end
+
+  operation :start, :method => :post, :member => true do
+    description "Start an instance"
+    param :id,           :string, :required
+    control { instance_action(:start) }
+  end
+
+  operation :stop, :method => :post, :member => true do
+    description "Stop running instance"
+    param :id,           :string, :required
+    control { instance_action(:stop) }
+  end
+
+  operation :destroy do
+    description "Destroy instance"
+    param :id,           :string, :required
+    control { instance_action(:destroy) }
+  end
+end
+
+collection :hardware_profiles do
+  description <<END
+ A hardware profile represents a configuration of resources upon which a
+ machine may be deployed. It defines aspects such as local disk storage,
+ available RAM, and architecture. Each provider is free to define as many
+ (or as few) hardware profiles as desired.
+END
+
+  operation :index do
+    description "List of available hardware profiles"
+    param :id,          :string
+    param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
+    control do
+        @profiles = driver.hardware_profiles(credentials, params)
+        respond_to do |format|
+          format.xml  { haml :'hardware_profiles/index' }
+          format.html  { haml :'hardware_profiles/index' }
+          format.json { convert_to_json(:hardware_profile, @profiles) }
+        end
+    end
+  end
+
+  operation :show do
+    description "Show specific hardware profile"
+    param :id,          :string,    :required
+    control do
+      @profile =  driver.hardware_profile(credentials, params[:id])
+      if @profile
+        respond_to do |format|
+          format.xml { haml :'hardware_profiles/show', :layout => false }
+          format.html { haml :'hardware_profiles/show' }
+          format.json { convert_to_json(:hardware_profile, @profile) }
+        end
+      else
+        report_error(404, 'not_found')
+      end
+    end
+  end
+
+end
+
+collection :storage_snapshots do
+  description "Storage snapshots description here"
+
+  operation :index do
+    description "Listing of storage snapshots"
+    param :id,            :string
+    control { filter_all(:storage_snapshots) }
+  end
+
+  operation :show do
+    description "Show storage snapshot"
+    param :id,          :string,    :required
+    control { show(:storage_snapshot) }
+  end
+end
+
+collection :storage_volumes do
+  description "Storage volumes description here"
+
+  operation :index do
+    description "Listing of storage volumes"
+    param :id,            :string
+    control { filter_all(:storage_volumes) }
+  end
+
+  operation :show do
+    description "Show storage volume"
+    param :id,          :string,    :required
+    control { show(:storage_volume) }
+  end
+end
+
+get '/api/keys/new' do
+  respond_to do |format|
+    format.html { haml :"keys/new" }
+  end
+end
+
+collection :keys do
+  description "Instance authentication credentials"
+
+  operation :index do
+    description "List all available credentials which could be used for instance authentication"
+    control do
+      filter_all :keys
+    end
+  end
+
+  operation :show do
+    description "Show details about given instance credential"
+    param :id,  :string,  :required
+    control { show :key }
+  end
+
+  operation :create do
+    description "Create a new instance credential if backend supports this"
+    param :name,  :string,  :required
+    control do
+      unless driver.respond_to?(:create_key)
+        raise Deltacloud::BackendFeatureUnsupported.new('501',
+          'Creating instance credentials is not supported in backend')
+      end
+      @key = driver.create_key(credentials, { :key_name => params[:name] })
+      respond_to do |format|
+        format.html { haml :"keys/show" }
+        format.xml { haml :"keys/show" }
+      end
+    end
+  end
+
+  operation :destroy do
+    description "Destroy given instance credential if backend supports this"
+    param :id,  :string,  :required
+    control do
+      unless driver.respond_to?(:destroy_key)
+        raise Deltacloud::BackendFeatureUnsupported.new('501',
+          'Creating instance credentials is not supported in backend')
+      end
+      driver.destroy_key(credentials, { :key_name => params[:id]})
+      redirect(keys_url)
+    end
+  end
+
+end

data/support/fedora/deltacloudd

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'thin'
+
+options = {
+  :env => 'production'
+}
+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!
+
+puts "Starting Deltacloud API :: #{ENV["API_DRIVER"]} :: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
+puts
+
+thin = Thin::Runner.new(argv_opts)
+begin
+  thin.run!
+rescue Exception => e
+  puts "ERROR: #{e.message}"
+end

data/support/fedora/rubygem-deltacloud-core.spec

@@ -0,0 +1,91 @@
+%global ruby_sitelib %(ruby -rrbconfig -e "puts Config::CONFIG['sitelibdir']")
+%global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
+%global gemname deltacloud-core
+%global geminstdir %{gemdir}/gems/%{gemname}-%{version}
+
+Summary: Deltacloud REST API
+Name: rubygem-%{gemname}
+Version: 0.0.1
+Release: 2%{?dist}
+Group: Development/Languages
+License: ASL 2.0 and MIT
+URL: http://www.deltacloud.org
+Source0: http://gems.rubyforge.org/gems/%{gemname}-%{version}.gem
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
+Requires: rubygems
+Requires: ruby(abi) = 1.8
+Requires: rubygem(eventmachine) >= 0.12.10
+Requires: rubygem(haml) >= 2.2.17
+Requires: rubygem(sinatra) >= 0.9.4
+Requires: rubygem(rack) >= 1.0.0
+Requires: rubygem(thin) >= 1.2.5
+Requires: rubygem(builder) >= 2.1.2
+Requires: rubygem(json) >= 1.2.3
+BuildRequires: ruby-json >= 1.1.9
+BuildRequires: rubygem(rake) >= 0.8.7
+BuildRequires: rubygem(rack-test) >= 0.4.0
+BuildRequires: rubygem(cucumber) >= 0.4.0
+BuildRequires: rubygem(rcov) >= 0.9.6
+BuildRequires: rubygems
+BuildRequires: ruby(abi) = 1.8
+BuildArch: noarch
+Provides: rubygem(%{gemname}) = %{version}
+
+%description
+The Deltacloud API is built as a service-based REST API.
+You do not directly link a Deltacloud library into your program to use it.
+Instead, a client speaks the Deltacloud API over HTTP to a server
+which implements the REST interface.
+
+%prep
+
+%build
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}%{gemdir}
+gem install --local --install-dir %{buildroot}%{gemdir} \
+            --force --rdoc %{SOURCE0}
+mkdir -p %{buildroot}/%{_bindir}
+mv %{buildroot}%{geminstdir}/support/fedora/deltacloudd %{buildroot}/%{geminstdir}/bin
+mv %{buildroot}%{gemdir}/bin/* %{buildroot}/%{_bindir}
+rmdir %{buildroot}%{gemdir}/bin
+find %{buildroot}%{geminstdir}/bin -type f | xargs chmod a+x
+
+# Needs json_pure gem / not available in Fedora yet
+#%check
+#pushd %{buildroot}%{geminstdir}
+#cucumber features/*.feature
+#popd
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-, root, root, -)
+%{_bindir}/deltacloudd
+%{gemdir}/gems/%{gemname}-%{version}/bin
+%{gemdir}/gems/%{gemname}-%{version}/lib
+%{gemdir}/gems/%{gemname}-%{version}/public/favicon.ico
+%{gemdir}/gems/%{gemname}-%{version}/public/images
+%{gemdir}/gems/%{gemname}-%{version}/public/stylesheets
+%{gemdir}/gems/%{gemname}-%{version}/tests
+%{gemdir}/gems/%{gemname}-%{version}/views
+%{gemdir}/gems/%{gemname}-%{version}/Rakefile
+%{gemdir}/gems/%{gemname}-%{version}/*.rb
+%{gemdir}/gems/%{gemname}-%{version}/config.ru
+%doc %{gemdir}/gems/%{gemname}-%{version}/support/fedora
+%doc %{gemdir}/gems/%{gemname}-%{version}/COPYING
+%doc %{gemdir}/doc/%{gemname}-%{version}
+%{gemdir}/cache/%{gemname}-%{version}.gem
+%{gemdir}/specifications/%{gemname}-%{version}.gemspec
+# MIT
+%{gemdir}/gems/%{gemname}-%{version}/public/javascripts
+
+%changelog
+* Mon Apr 26 2010 Michal Fojtik <mfojtik@packager> - 0.0.1-1
+- Initial package
+
+* Mon Apr 26 2010 Michal Fojtik <mfojtik@packager> - 0.0.1-2
+- Fixed broken dependencies
+- Added new launcher for Fedora

data/tests/api_test.rb

@@ -0,0 +1,37 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class ApiTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_returns_entry_points
+      do_xml_request '/api'
+      (last_xml_response/'/api/link').map.size.should > 0
+    end
+
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api'
+      (last_xml_response/'/api/link').each do |link|
+        link.attributes.keys.sort.should == [ 'href', 'rel' ]
+      end
+    end
+
+    def test_it_responses_to_html
+      do_request '/api', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_responses_to_json
+      do_request '/api', {}, false, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['api'].class.should == Hash
+    end
+
+  end
+end

data/tests/hardware_profiles_test.rb

@@ -0,0 +1,120 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class HardwareProfilesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_returns_hardware_profiles
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').map.size.should > 0
+    end
+
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        profile.attributes.keys.sort.should == [ 'href', 'id' ]
+      end
+    end
+
+    def test_hardware_profiles_have_name
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        (profile/'name').text.should_not == nil
+      end
+    end
+
+    def test_hardware_profiles_have_unique_name
+      do_xml_request '/api/hardware_profiles'
+      names = []
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        names << (profile/'name').text
+      end
+      names.should == names.uniq
+    end
+
+    def test_hardware_profiles_have_unique_id
+      do_xml_request '/api/hardware_profiles'
+      ids = []
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        ids << profile['id']
+      end
+      ids.should == ids.uniq
+    end
+
+    def test_m1_xlarge_profile_has_correct_attributes
+      do_xml_request '/api/hardware_profiles'
+      profile = (last_xml_response/'hardware_profiles/hardware_profile[@id="m1-xlarge"]')
+      test_profile_properties(profile)
+    end
+
+    def test_it_returns_valid_hardware_profile
+      do_xml_request '/api/hardware_profiles/m1-xlarge'
+      profile = (last_xml_response/'hardware_profile')
+      test_profile_properties(profile)
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/hardware_profiles', {}, false, { :format => :json }
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['hardware_profiles'].class.should == Array
+
+      do_request '/api/hardware_profiles/m1-xlarge', {}, false, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['hardware_profile'].class.should == Hash
+    end
+
+    def test_it_responses_to_html
+      do_request '/api/hardware_profiles', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+
+      do_request '/api/hardware_profiles/m1-xlarge', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_returns_error_on_wrong_name
+      do_request '/api/hardware_profiles/m1-unknown-wrongname', {}, false, { :format => :html }
+      last_response.status.should == 404
+      do_xml_request '/api/hardware_profiles/m1-unknown-wrongname'
+      last_response.status.should == 404
+      do_request '/api/hardware_profiles/m1-unknown-wrongname', {}, false, { :format => :json }
+      last_response.status.should == 404
+    end
+
+    private
+
+    def test_profile_properties(profile)
+      
+      (profile/'property').each do |properties|
+        properties.attributes.keys.sort.should == [ 'kind', 'name', 'unit', 'value' ]
+      end
+
+      (profile/'property[@name="architecture"]').first['kind'].should == 'fixed'
+      (profile/'property[@name="architecture"]').first['unit'].should == 'label'
+      
+      (profile/'property[@name="memory"]').first['kind'].should == 'range'
+      (profile/'property[@name="memory"]').first['unit'].should == 'MB'
+      (profile/'property[@name="memory"]/range').size.should == 1
+      (profile/'property[@name="memory"]/range').first.attributes.keys.sort.should == [ 'first', 'last' ]
+
+      (profile/'property[@name="cpu"]').first['kind'].should == 'fixed'
+      (profile/'property[@name="cpu"]').first['unit'].should == 'count'
+      
+      (profile/'property[@name="storage"]').first['kind'].should == 'enum'
+      (profile/'property[@name="storage"]').first['unit'].should == 'GB'
+      (profile/'property[@name="storage"]/enum').size.should == 1
+      (profile/'property[@name="storage"]/enum/entry').map.size.should == 3
+      (profile/'property[@name="storage"]/enum/entry').each do |entry|
+        entry.attributes.keys.should == [ 'value' ]
+        entry['value'].should_not == nil
+      end
+    end
+
+  end
+end