steamcannon-deltacloud-core 0.0.8.1 → 0.1.1.1

data/lib/deltacloud/models/storage_volume.rb

@@ -24,5 +24,7 @@ class StorageVolume < BaseModel
   attr_accessor :capacity
   attr_accessor :instance_id
   attr_accessor :device
+  attr_accessor :realm_id
+  attr_accessor :actions
 
 end

data/lib/sinatra/rabbit.rb

@@ -1,6 +1,7 @@
 require 'sinatra/base'
 require 'sinatra/url_for'
 require 'deltacloud/validation'
+require 'deltacloud/backend_capability'
 
 module Sinatra
 
@@ -13,6 +14,7 @@ module Sinatra
     class Operation
       attr_reader :name, :method
 
+      include ::Deltacloud::BackendCapability
       include ::Deltacloud::Validation
 
       STANDARD = {
@@ -55,15 +57,10 @@ module Sinatra
         end
       end
 
-      def control(opts=nil, &block)
+      def control(&block)
         op = self
         @control = Proc.new do
-          if opts and
-              opts[:with_feature] and
-              !driver.respond_to?(opts[:with_feature])
-            raise Deltacloud::BackendFeatureUnsupported.new('501', nil,
-              "#{opts[:with_feature]} not supported by backend", nil)
-          end
+          op.check_capability(driver)
           op.validate(params)
           instance_eval(&block)
         end

data/public/javascripts/application.js

@@ -3,30 +3,16 @@
 
 $(document).ready(function() {
 
-  $("a.delete").click(function(e) {
-    var original_url = $(this).attr('href')
-    $.ajax({
-      url : original_url,
-      type : 'DELETE',
-      cache : false,
-      success: function(data) {
-        window.location = original_url.replace(/\/([\w_-]+)$/i, '')
+  if ($('select#list_instances').length) {
+    $('select#list_instances').html("<option>Loading instances...</option>");
+    $.getJSON("/api/instances?state=RUNNING&format=json",
+      function(data){
+        $('select#list_instances').empty();
+        $.each(data.instances, function(i,item){
+          $('select#list_instances').append('<option value="'+item.id+'">'+item.id+'</option>');
+        });
       }
-    })
-    return false;
-  })
-
-  $("a.post").click(function(e) {
-    var original_url = $(this).attr('href')
-    $.ajax({
-      url : original_url,
-      type : 'POST',
-      dataType : 'xml',
-      success: function(data) {
-        window.location = original_url.replace(/\/([\w_-]+)$/i, '')
-      }
-    })
-    return false;
-  })
+    );
+  }
 
 })

data/public/stylesheets/compiled/application.css

@@ -611,3 +611,5 @@ input[type='radio'] {
 table.docs { border : 1px solid #ccc }
 table.docs td { border : 1px solid #ccc }
 table.docs table td { border : none }
+
+td form.link { display : inline }

data/server.rb

@@ -32,6 +32,9 @@ error Deltacloud::Validation::Failure do
   report_error(400, "validation_failure")
 end
 
+error Deltacloud::BackendCapability::Failure do
+  report_error(405, "backend_capability_failure")
+end
 error Deltacloud::AuthException do
   report_error(403, "auth_exception")
 end
@@ -82,6 +85,7 @@ END
     Operation will list all available realms. Realms can be filtered using
     the "architecture" parameter.
 END
+    with_capability :realms
     param :id,            :string
     param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
     control { filter_all(:realms) }
@@ -90,6 +94,7 @@ END
   #FIXME: It always shows whole list
   operation :show do
     description 'Show an realm identified by "id" parameter.'
+    with_capability :realm
     param :id,           :string, :required
     control { show(:realm) }
   end
@@ -108,6 +113,7 @@ END
     available to the current use. Images can be filtered using the
     "owner_id" and "architecture" parameters.
 END
+    with_capability :images
     param :id,            :string
     param :architecture,  :string,  :optional
     control { filter_all(:images) }
@@ -115,6 +121,7 @@ END
 
   operation :show do
     description 'Show an image identified by "id" parameter.'
+    with_capability :image
     param :id,           :string, :required
     control { show(:image) }
   end
@@ -168,11 +175,87 @@ get "/api/instances/new" do
   @image   = driver.image( credentials, :id => params[:image_id] )
   @hardware_profiles = driver.hardware_profiles(credentials, :architecture => @image.architecture )
   @realms = driver.realms(credentials)
+  if driver_has_feature?(:register_to_load_balancer)
+    @load_balancers = driver.load_balancers(credentials)
+  end
   respond_to do |format|
     format.html { haml :"instances/new" }
   end
 end
 
+get '/api/load_balancers/new' do
+  @realms = driver.realms(credentials)
+  @instances = driver.instances(credentials) if driver_has_feature?(:register_instance, :load_balancers)
+  respond_to do |format|
+    format.html { haml :"load_balancers/new" }
+  end
+end
+
+
+collection :load_balancers do
+  description "Load balancers"
+
+  operation :index do
+    description "List of all active load balancers"
+    control do
+      filter_all :load_balancers
+    end
+  end
+
+  operation :show do
+    description "Show details about given load balancer"
+    param :id,  :string,  :required
+    control { show :load_balancer }
+  end
+
+  operation :create do
+    description "Create a new load balancer"
+    param :name,  :string,  :required
+    param :realm_id,  :string,  :required
+    param :listener_protocol,  :string,  :required, ['HTTP', 'TCP']
+    param :listener_balancer_port,  :string,  :required
+    param :listener_instance_port,  :string,  :required
+    control do
+      @load_balancer = driver.create_load_balancer(credentials, params)
+      respond_to do |format|
+        format.xml { haml :"load_balancers/show" }
+        format.html { haml :"load_balancers/show" }
+      end
+    end
+  end
+
+  operation :register, :method => :post, :member => true do
+    description "Add instance to loadbalancer"
+    param :id,  :string,  :required
+    param :instance_id, :string,  :required
+    control do
+      driver.lb_register_instance(credentials, params)
+      redirect(load_balancer_url(params[:id]))
+    end
+  end
+
+  operation :unregister, :method => :post, :member => true do
+    description "Remove instance from loadbalancer"
+    param :id,  :string,  :required
+    param :instance_id, :string,  :required
+    control do
+      driver.lb_unregister_instance(credentials, params)
+      redirect(load_balancer_url(params[:id]))
+    end
+  end
+
+  operation :destroy do
+    description "Destroy given load balancer"
+    param :id,  :string,  :required
+    control do
+      driver.destroy_load_balancer(credentials, params[:id])
+      redirect(load_balancers_url)
+    end
+  end
+
+end
+
+
 collection :instances do
   description <<END
   An instance is a concrete machine realized from an image.
@@ -181,6 +264,7 @@ END
 
   operation :index do
     description "List all instances."
+    with_capability :instances
     param :id,            :string,  :optional
     param :state,         :string,  :optional
     control { filter_all(:instances) }
@@ -188,12 +272,14 @@ END
 
   operation :show do
     description 'Show an instance identified by "id" parameter.'
+    with_capability :instance
     param :id,           :string, :required
     control { show(:instance) }
   end
 
   operation :create do
     description "Create a new instance."
+    with_capability :create_instance
     param :image_id,     :string, :required
     param :realm_id,     :string, :optional
     param :hwp_id,       :string, :optional
@@ -217,24 +303,28 @@ END
 
   operation :reboot, :method => :post, :member => true do
     description "Reboot a running instance."
+    with_capability :reboot_instance
     param :id,           :string, :required
     control { instance_action(:reboot) }
   end
 
   operation :start, :method => :post, :member => true do
     description "Start an instance."
+    with_capability :start_instance
     param :id,           :string, :required
     control { instance_action(:start) }
   end
 
   operation :stop, :method => :post, :member => true do
     description "Stop a running instance."
+    with_capability :stop_instance
     param :id,           :string, :required
     control { instance_action(:stop) }
   end
 
   operation :destroy do
     description "Destroy an instance."
+    with_capability :destroy_instance
     param :id,           :string, :required
     control { instance_action(:destroy) }
   end
@@ -250,6 +340,7 @@ END
 
   operation :index do
     description "List of available hardware profiles."
+    with_capability :hardware_profiles
     param :id,          :string
     param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
     control do
@@ -264,6 +355,7 @@ END
 
   operation :show do
     description "Show specific hardware profile."
+    with_capability :hardware_profile
     param :id,          :string,    :required
     control do
       @profile =  driver.hardware_profile(credentials, params[:id])
@@ -281,110 +373,127 @@ END
 
 end
 
+get '/api/storage_snapshots/new' do
+  respond_to do |format|
+    format.html { haml :"storage_snapshots/new" }
+  end
+end
+
 collection :storage_snapshots do
   description "Storage snapshots description here"
 
   operation :index do
     description "List of storage snapshots."
+    with_capability :storage_snapshots
     param :id,            :string
     control { filter_all(:storage_snapshots) }
   end
 
   operation :show do
     description "Show storage snapshot."
+    with_capability :storage_snapshot
     param :id,          :string,    :required
     control { show(:storage_snapshot) }
   end
+
+  operation :create do
+    description "Create a new snapshot from volume"
+    with_capability :create_storage_snapshot
+    param :volume_id, :string,  :required
+    control do
+      @storage_snapshot = driver.create_storage_snapshot(credentials, params)
+      show(:storage_snapshot)
+    end
+  end
+
+  operation :destroy do
+    description "Delete storage snapshot"
+    with_capability :destroy_storage_snapshot
+    param :id,  :string,  :required
+    control do
+      driver.create_storage_snapshot(credentials, params)
+      redirect(storage_snapshot_url(params[:id]))
+    end
+  end
+
+end
+
+get '/api/storage_volumes/new' do
+  respond_to do |format|
+    format.html { haml :"storage_volumes/new" }
+  end
 end
 
-# get '/api/storage_volumes/new' do
-#   respond_to do |format|
-#     format.html { haml :"storage_volumes/new" }
-#   end
-# end
+get '/api/storage_volumes/attach' do
+  respond_to do |format|
+    @instances = driver.instances(credentials)
+    format.html { haml :"storage_volumes/attach" }
+  end
+end
 
 collection :storage_volumes do
   description "Storage volumes description here"
 
   operation :index do
     description "List of storage volumes."
+    with_capability :storage_volumes
     param :id,            :string
     control { filter_all(:storage_volumes) }
   end
 
   operation :show do
     description "Show storage volume."
+    with_capability :storage_volume
     param :id,          :string,    :required
     control { show(:storage_volume) }
   end
 
   operation :create do
-    description "Create new storage volume if backend supports them."
-    param :realm_id,     :string, :required
-    param :capacity,         :string, :required
-    control(:with_feature => :create_storage_volume) do
-      volume = driver.create_storage_volume(credentials, params)
+    description "Create a new storage volume"
+    with_capability :create_storage_volume
+    param :snapshot_id, :string,  :optional
+    param :capacity,    :string,  :optional
+    param :realm_id,    :string,  :optional
+    control do
+      @storage_volume = driver.create_storage_volume(credentials, params)
       respond_to do |format|
-        format.xml do
-          response.status = 201  # Created
-          response['Location'] = storage_volume_url(volume.id)
-          @storage_volume = volume
-          haml :"storage_volumes/show"
-        end
-        format.html do
-          redirect storage_volume_url(volume.id) if volume and volume.id
-          redirect storage_volumes_url
-        end
+        format.html { haml :"storage_volumes/show" }
+        format.xml { haml :"storage_volumes/show" }
       end
     end
   end
-  
-   operation :destroy do
-    param :id,  :string,  :required
-    control :with_feature => :destroy_storage_volume do
-      driver.destroy_storage_volume(credentials, params[:id])
-      redirect(storage_volumes_url)
-    end
-  end
 
   operation :attach, :method => :post, :member => true do
-    param :id,  :string,  :required
-    param :instance_id, :string, :required
-    param :device, :string, :required
-    
-    control :with_feature => :attach_storage_volume do
-      volume = driver.attach_storage_volume(credentials, params)
-      respond_to do |format|
-        format.xml do
-          response.status = 200
-          response['Location'] = storage_volume_url(volume.id)
-          @storage_volume = volume
-          haml :"storage_volumes/show"
-        end
-        format.html do
-          redirect storage_volume_url(volume.id)
-        end
-      end
+    description "Attach storage volume to instance"
+    with_capability :attach_storage_volume
+    param :id,         :string,  :required
+    param :instance_id,:string,  :required
+    param :device,     :string,  :required
+    control do
+      driver.attach_storage_volume(credentials, params)
+      redirect(storage_volume_url(params[:id]))
     end
   end
 
-  
   operation :detach, :method => :post, :member => true do
-    param :id,  :string,  :required
+    description "Detach storage volume to instance"
+    with_capability :detach_storage_volume
+    param :id,         :string,  :required
+    control do
+      volume = driver.storage_volume(credentials, :id => params[:id])
+      driver.detach_storage_volume(credentials, :id => volume.id, :instance_id => volume.instance_id,
+                                   :device => volume.device)
+      redirect(storage_volume_url(params[:id]))
+    end
+  end
 
-    control :with_feature => :detach_storage_volume do
-      volume = driver.detach_storage_volume(credentials, params[:id])
-      respond_to do |format|
-        format.xml do
-          response.status = 200
-          response['Location'] = storage_volume_url(volume.id)
-          @storage_volume = volume
-          haml :"storage_volumes/show"
-        end
-        format.html do
-          redirect storage_volume_url(volume.id)
-        end
-      end
+  operation :destroy do
+    description "Destroy storage volume"
+    with_capability :destroy_storage_volume
+    param :id,          :string,  :optional
+    control do
+      driver.destroy_storage_volume(credentials, params)
+      redirect(storage_volumes_url)
     end
   end
 
@@ -401,6 +510,7 @@ collection :keys do
 
   operation :index do
     description "List all available credentials which could be used for instance authentication."
+    with_capability :keys
     control do
       filter_all :keys
     end
@@ -408,18 +518,16 @@ collection :keys do
 
   operation :show do
     description "Show details about given instance credential."
+    with_capability :key
     param :id,  :string,  :required
     control { show :key }
   end
 
   operation :create do
     description "Create a new instance credential if backend supports this."
+    with_capability :create_key
     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" }
@@ -430,12 +538,9 @@ collection :keys do
 
   operation :destroy do
     description "Destroy given instance credential if backend supports this."
+    with_capability :destroy_key
     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
@@ -443,6 +548,35 @@ collection :keys do
 
 end
 
+#get html form for creating a new blob
+get '/api/buckets/:bucket/new_blob' do
+  @bucket_id = params[:bucket]
+  respond_to do |format|
+    format.html {haml :"blobs/new"}
+  end
+end
+
+#create a new blob
+post '/api/buckets/:bucket' do
+  bucket_id = params[:bucket]
+  blob_id = params['blob_id']
+  blob_data = params['blob_data']
+  @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data )
+  respond_to do |format|
+    format.html { haml :"blobs/show"}
+    format.xml { haml :"blobs/show" }
+  end
+end
+
+#delete a blob
+delete '/api/buckets/:bucket/:blob' do
+  bucket_id = params[:bucket]
+  blob_id = params[:blob]
+  driver.delete_blob(credentials, bucket_id, blob_id)
+  redirect(bucket_url(bucket_id))
+end
+
+#Get a particular blob's particulars (not actual blob data)
 get '/api/buckets/:bucket/:blob' do
   @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
   if @blob
@@ -456,13 +590,7 @@ get '/api/buckets/:bucket/:blob' do
   end
 end
 
-get '/api/buckets/new' do
-  respond_to do |format|
-    format.html { haml :"buckets/new" }
-  end
-end
-
-
+#get the content of a particular blob
 get '/api/buckets/:bucket/:blob/content' do
   @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
   params['content_length'] = @blob.content_length
@@ -470,11 +598,19 @@ get '/api/buckets/:bucket/:blob/content' do
   BlobStream.call(env, credentials, params)
 end
 
+#Get html form for creating a new bucket
+get '/api/buckets/new' do
+  respond_to do |format|
+    format.html { haml :"buckets/new" }
+  end
+end
+
 collection :buckets do
   description "Cloud Storage buckets - aka buckets|directories|folders"
 
   operation :index do
     description "List buckets associated with this account"
+    with_capability :buckets
     param :id,        :string
     param :name,      :string
     param :size,      :string
@@ -483,12 +619,14 @@ collection :buckets do
 
   operation :show do
     description "Show bucket"
+    with_capability :bucket
     param :id,        :string
     control { show(:bucket) }
   end
 
   operation :create do
     description "Create a new bucket (POST /api/buckets)"
+    with_capability :create_bucket
     param :name,      :string,    :required
     control do
       @bucket = driver.create_bucket(credentials, params[:name], params)
@@ -508,6 +646,7 @@ collection :buckets do
 
   operation :destroy do
     description "Delete a bucket by name - bucket must be empty"
+    with_capability :delete_bucket
     param :id,    :string,    :required
     control do
       driver.delete_bucket(credentials, params[:id], params)