deltacloud-core 1.0.5 → 1.1.0

data/lib/cimi/models/volume_configuration.rb

@@ -25,35 +25,67 @@ class CIMI::Model::VolumeConfiguration < CIMI::Model::Base
     scalar :rel, :href
   end
 
+  def self.create_from_json(body, context)
+    json = JSON.parse(body)
+    new_config = current_db.add_volume_configuration(
+      :name => json['name'],
+      :description => json['description'],
+      :format => json['format'],
+      :capacity => json['capacity'],
+      :ent_properties => json['properties'].to_json
+    )
+    from_db(new_config, context)
+  end
+
+  def self.create_from_xml(body, context)
+    xml = XmlSimple.xml_in(body)
+    xml['property'] ||= []
+    new_config = current_db.add_volume_configuration(
+      :name => xml['name'].first,
+      :description => xml['description'].first,
+      :format => xml['format'].first,
+      :capacity => xml['capacity'].first,
+      :ent_properties => JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r })
+    )
+    from_db(new_config, context)
+  end
+
+  def self.delete!(id, context)
+    current_db.volume_configurations.first(:id => id).destroy
+  end
+
   def self.find(id, context)
-    volume_configs = []
-    if id == :all
-      #ec2 ebs volumes can 1gb..1tb
-      (1..1000).each do |size|
-        volume_configs << create(size, context)
+    if id==:all
+      if context.driver.respond_to? :volume_configurations
+        context.driver.volume_configurations(context.credentials, {:env=>context})
+      else
+        current_db.volume_configurations.map { |t| from_db(t, context) }
       end
     else
-      volume_configs << create(id, context)
-      return volume_configs.first
+      if context.driver.respond_to? :volume_configuration
+        context.driver.volume_configuration(context.credentials, id, :env=>context)
+      else
+        config = current_db.volume_configurations_dataset.first(:id => id)
+        raise CIMI::Model::NotFound unless config
+        from_db(config, context)
+      end
     end
-    return volume_configs
   end
 
-
-  def self.all(context); find(:all, context); end
-
   private
 
-  def self.create(size, context)
-    self.new( {
-                :id => context.volume_configuration_url(size),
-                :name => "volume-#{size}",
-                :description => "Volume configuration with #{size} kilobytes",
-                :created => Time.now.xmlschema,
-                :capacity => context.to_kibibyte(size, "MB"),
-                :supports_snapshots => "true"
-                # FIXME :guest_interface => "NFS"
-            } )
+  def self.from_db(model, context)
+    self.new(
+      :id => context.volume_configuration_url(model.id),
+      :name => model.name,
+      :description => model.description,
+      :format => model.format,
+      :capacity => context.to_kibibyte(model.capacity, "GB"),
+      :property => JSON::parse(model.ent_properties),
+      :operations => [
+        { :href => context.destroy_volume_configuration_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+      ]
+    )
   end
 
 end

data/lib/cimi/models/volume_image.rb

@@ -25,23 +25,38 @@ class CIMI::Model::VolumeImage < CIMI::Model::Base
   end
 
   def self.find(id, context)
-    storage_snapshots = []
-    opts = ( id==:all  ) ? {}  : { :id=>id }
-    storage_snapshots = context.driver.storage_snapshots(context.credentials, opts)
-    storage_snapshots.collect!{ |snapshot| from_storage_snapshot(snapshot, context) }
-    return storage_snapshots.first unless storage_snapshots.length > 1
-    return storage_snapshots
+    creds = context.credentials
+    if id == :all
+      snapshots = context.driver.storage_snapshots(creds)
+      snapshots.collect{ |snapshot| from_storage_snapshot(snapshot, context) }
+    else
+      snapshot = context.driver.storage_snapshots(creds, id => :id).first
+      raise CIMI::Model::NotFound unless snapshot
+      from_storage_snapshot(snapshot, context)
+    end
   end
 
   def self.all(context); find(:all, context); end
 
+  def self.create(request_body, context)
+    type = context.grab_content_type(context.request.content_type, request_body)
+    input = (type == :xml)? XmlSimple.xml_in(request_body.read, {"ForceArray"=>false,"NormaliseSpace"=>2}) : JSON.parse(request_body.read)
+    params = {:volume_id => context.href_id(input["imageLocation"]["href"], :volumes), :name=>input["name"], :description=>input["description"]}
+    vol_image = context.driver.create_storage_snapshot(context.credentials, params)
+    from_storage_snapshot(vol_image, context)
+  end
+
+  def self.delete!(vol_image_id, context)
+    context.driver.destroy_storage_snapshot(context.credentials, {:id=>vol_image_id})
+  end
+
   private
 
   def self.from_storage_snapshot(snapshot, context)
     self.new( {
-               :name => snapshot.id,
-               :description => snapshot.id,
-               :created => Time.parse(snapshot.created).xmlschema,
+               :name => snapshot.name || snapshot.id,
+               :description => snapshot.description || snapshot.id,
+               :created => snapshot.created.nil? ? nil : Time.parse(snapshot.created).xmlschema,
                :id => context.volume_image_url(snapshot.id),
                :image_location => {:href=>context.volume_url(snapshot.storage_volume_id)},
                :bootable => "false"  #FIXME

data/lib/cimi/models/volume_template.rb

@@ -19,7 +19,68 @@ class CIMI::Model::VolumeTemplate < CIMI::Model::Base
 
   href :volume_config
   href :volume_image
+
+  array :meter_templates do
+  end
+
+  href :event_log_template
+
   array :operations do
     scalar :rel, :href
   end
+
+  def self.find(id, context)
+    if id==:all
+      if context.driver.respond_to? :volume_templates
+        context.driver.volume_templates(context.credentials, {:env=>context})
+      else
+        current_db.volume_templates.map { |t| from_db(t, context) }
+      end
+    else
+      if context.driver.respond_to? :volume_template
+        context.driver.volume_template(context.credentials, id, :env=>context)
+      else
+        template = current_db.volume_templates_dataset.first(:id => id)
+        raise CIMI::Model::NotFound unless template
+        from_db(template, context)
+      end
+    end
+  end
+
+  def self.create(body, context, type)
+    input = (type == :xml)? XmlSimple.xml_in(body, {"ForceArray"=>false,"NormaliseSpace"=>2}) : JSON.parse(body)
+    input['property'] ||= []
+    vol_image = input['volumeImage']['href'] if input['volumeImage']
+    new_template = current_db.add_volume_template(
+      :name => input['name'],
+      :description => input['description'],
+      :volume_config => input['volumeConfig']['href'],
+      :volume_image => vol_image,
+      :ent_properties => JSON::dump(input['property'].inject({}) { |r, p| r[p['key']]=p['content']; r })
+    )
+    from_db(new_template, context)
+  end
+
+  def self.delete!(id, context)
+    current_db.volume_templates.first(:id => id).destroy
+  end
+
+private
+
+  def self.from_db(model, context)
+    self.new(
+      :id => context.volume_template_url(model.id),
+      :name => model.name,
+      :description => model.description,
+      :volume_config => {:href => model.volume_config},
+      :volume_image => {:href => model.volume_image},
+      :property => JSON::parse(model.ent_properties),
+      :operations => [
+        { :href => context.destroy_volume_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+      ]
+    )
+  end
+
+
+
 end

data/lib/cimi/server.rb

@@ -14,8 +14,6 @@
 # under the License.
 
 require 'rubygems'
-require 'crack'
-require 'json'
 require 'yaml'
 require 'haml'
 require 'sinatra/base'
@@ -49,9 +47,5 @@ module CIMI
 
     helpers Sinatra::Rabbit::URLFor(CIMI.collections)
 
-    get '/' do
-      redirect url('/cloudEntryPoint'), 301
-    end
-
   end
 end

data/lib/db.rb

@@ -0,0 +1,82 @@
+module Deltacloud
+
+  def self.test_environment?
+    ENV['RACK_ENV'] == 'test'
+  end
+
+  unless test_environment?
+    require 'sequel'
+    require 'logger'
+    Sequel::Model.plugin :validation_class_methods
+  end
+
+  if RUBY_PLATFORM == 'java'
+    DATABASE_LOCATION = ENV['DATABASE_LOCATION'] ||
+      'jdbc:sqlite:'+File.join('/', 'var', 'tmp', "deltacloud-mock-#{ENV['USER']}", 'db.sqlite')
+  else
+    DATABASE_LOCATION = ENV['DATABASE_LOCATION'] ||
+      'sqlite://'+File.join('/', 'var', 'tmp', "deltacloud-mock-#{ENV['USER']}", 'db.sqlite')
+  end
+
+  def self.database(opts={})
+    opts[:logger] = ::Logger.new($stdout) if ENV['API_VERBOSE']
+    @db ||=  Sequel.connect(DATABASE_LOCATION, opts)
+  end
+
+  def self.initialize_database
+    db = database
+
+    db.create_table?(:providers) {
+      primary_key :id
+
+      column :driver, :string, { :null => false }
+      column :url, :string
+      index [ :url, :driver ] if !db.table_exists?(:providers)
+    }
+
+    db.create_table?(:entities) {
+      primary_key :id
+
+      unless db.table_exists?(:entities)
+        foreign_key :provider_id, :providers, { :index => true, :null => false }
+      end
+
+      column :created_at, :timestamp
+
+      # Base
+      unless db.table_exists?(:entities)
+        column :model, :string, { :index => true, :null => false, :default => 'entity' }
+      end
+
+      # Map Entity to Deltacloud model
+      # (like: Machine => Instance)
+      column :be_kind, :string
+      column :be_id, :string
+
+      # Entity
+      column :name, :string
+      column :description, :string
+      column :ent_properties, :string, { :text => true }
+
+
+      column :machine_config, :string
+      column :machine_image, :string
+
+      column :network, :string
+      column :ip, :string
+      column :hostname, :string
+      column :allocation, :string
+      column :default_gateway, :string
+      column :dns, :string
+      column :protocol, :string
+      column :mask, :string
+
+      column :format, :string
+      column :capacity, :string
+
+      column :volume_config, :string
+      column :volume_image, :string
+    }
+  end
+
+end

data/lib/db/address_template.rb

@@ -0,0 +1,15 @@
+module Deltacloud
+  module Database
+
+    class AddressTemplate < Entity
+      validates_presence_of :ip
+      validates_presence_of :hostname
+      validates_presence_of :allocation
+      validates_presence_of :default_gateway
+      validates_presence_of :dns
+      validates_presence_of :protocol
+      validates_presence_of :mask
+    end
+
+  end
+end

data/lib/db/entity.rb

@@ -0,0 +1,22 @@
+module Deltacloud
+  module Database
+
+    class Entity < Sequel::Model
+
+      many_to_one :provider
+
+      plugin :single_table_inheritance, :model
+      plugin :timestamps, :create => :created_at
+
+      def to_hash
+        retval = {}
+        retval.merge!(:name => self.name) if !self.name.nil?
+        retval.merge!(:description => self.description) if !self.description.nil?
+        retval.merge!(:property => JSON::parse(self.ent_properties)) if !self.ent_properties.nil?
+        retval
+      end
+
+    end
+
+  end
+end

data/lib/db/machine_template.rb

@@ -0,0 +1,10 @@
+module Deltacloud
+  module Database
+
+    class MachineTemplate < Entity
+      validates_presence_of :machine_config
+      validates_presence_of :machine_image
+    end
+
+  end
+end

data/lib/db/provider.rb

@@ -0,0 +1,13 @@
+module Deltacloud
+  module Database
+
+    class Provider < Sequel::Model
+      one_to_many :entities
+      one_to_many :machine_templates
+      one_to_many :address_templates
+      one_to_many :volume_templates
+      one_to_many :volume_configurations
+    end
+
+  end
+end

data/lib/db/volume_configuration.rb

@@ -0,0 +1,10 @@
+module Deltacloud
+  module Database
+
+    class VolumeConfiguration < Entity
+      validates_presence_of :format
+      validates_presence_of :capacity
+    end
+
+  end
+end

data/lib/db/volume_template.rb

@@ -0,0 +1,10 @@
+module Deltacloud
+  module Database
+
+    class VolumeTemplate < Entity
+      validates_presence_of :volume_config
+      validates_presence_of :volume_Image
+    end
+
+  end
+end

data/lib/deltacloud/collections/addresses.rb

@@ -41,7 +41,7 @@ module Deltacloud::Collections
           respond_to do |format|
             format.xml  { haml :"addresses/show", :ugly => true }
             format.html { haml :"addresses/_address", :layout => false }
-            format.json { xml_to_json("addresses/show") }
+            format.json { JSON::dump(:address => @address.to_hash(self)) }
           end
         end
       end

data/lib/deltacloud/collections/base.rb

@@ -43,7 +43,18 @@ module Deltacloud::Collections
       report_error
     end
 
-    error Deltacloud::Exceptions::ValidationFailure do
+    # error Deltacloud::Exceptions::ObjectNotFound do
+    #   report_error
+    # end
+
+    error Deltacloud::Exceptions::AcceptedButNotCompletedError,
+          Deltacloud::Exceptions::ValidationFailure,
+          Deltacloud::Exceptions::AuthenticationFailure,
+          Deltacloud::Exceptions::ForbiddenError,
+          Deltacloud::Exceptions::ObjectNotFound,
+          Deltacloud::Exceptions::MethodNotAllowed,
+          Deltacloud::Exceptions::UnknownMediaTypeError,
+          Deltacloud::Exceptions::Conflict do
       report_error
     end
 

data/lib/deltacloud/collections/buckets.rb

@@ -49,8 +49,41 @@ module Deltacloud::Collections
       end
     end
 
+    put "/segmented_blob_operation/:bucket/:blob" do
+      case BlobHelper.segmented_blob_op_type(request)
+        when "init" then
+          segmented_blob_id = driver.init_segmented_blob(credentials, {:id => params[:blob],
+                                            :bucket => params[:bucket]})
+          headers["X-Deltacloud-SegmentedBlob"] = segmented_blob_id
+          status 204
+        when "segment" then
+          if env["BLOB_SUCCESS"] # set by blob_stream_helper after succesful stream PUT
+            #segment already uploaded by blob_streaming_patch - setting blob_segment-id from the response
+            headers["X-Deltacloud-BlobSegmentId"] = request.env["BLOB_SEGMENT_ID"] # set in blob_stream_helper: 203
+            status 204
+          else
+            report_error(400) # likely blob size < 112 KB (didn't hit streaming patch)
+          end
+        when "finalize" then
+          bucket_id = params[:bucket]
+          blob_id = params[:blob]
+          segmented_blob_manifest = BlobHelper.extract_segmented_blob_manifest(request)
+          segmented_blob_id = BlobHelper.segmented_blob_id(request)
+          @blob = driver.create_blob(credentials, params[:bucket], params[:blob], nil, {:segment_manifest=>segmented_blob_manifest, :segmented_blob_id=>segmented_blob_id})
+          respond_to do |format|
+            format.xml { haml :"blobs/show" }
+            format.html { haml :"blobs/show" }
+            format.json { xml_to_json 'blobs/show' }
+          end
+        else
+          report_error(500)
+      end
+    end
+
     put "/buckets/:bucket/:blob" do
-      if(env["BLOB_SUCCESS"]) #ie got a 200ok after putting blob
+      if BlobHelper.segmented_blob(request)
+        status, headers, body = call!(env.merge("PATH_INFO" => "/segmented_blob_operation/#{params[:bucket]}/#{params[:blob]}"))
+      elsif(env["BLOB_SUCCESS"]) #ie got a 200ok after putting blob
         content_type = env["CONTENT_TYPE"]
         content_type ||=  ""
         @blob = driver.blob(credentials, {:id => params[:blob],
@@ -58,7 +91,7 @@ module Deltacloud::Collections
         respond_to do |format|
           format.xml { haml :"blobs/show" }
           format.html { haml :"blobs/show" }
-          format.json { xml_to_json 'blobs/show' }
+          format.json { JSON::dump(:blob => @blob.to_hash(self) ) }
         end
       elsif(env["BLOB_FAIL"])
         report_error(500) #OK?
@@ -77,7 +110,7 @@ module Deltacloud::Collections
         respond_to do |format|
           format.xml { haml :"blobs/show" }
           format.html { haml :"blobs/show" }
-          format.json { xml_to_json 'blobs/show' }
+          format.json { JSON::dump(:blob => @blob.to_hash(self)) }
         end
       end
     end
@@ -96,7 +129,7 @@ module Deltacloud::Collections
           response['Location'] = bucket_url(@bucket.id)
           respond_to do |format|
             format.xml  { haml :"buckets/show" }
-            format.json { xml_to_json('buckets/show') }
+            format.json { JSON::dump(:bucket => @bucket.to_hash(self)) }
             format.html do
               redirect bucket_url(@bucket.id) if @bucket and @bucket.id
               redirect buckets_url
@@ -127,7 +160,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { xml_to_json 'blobs/show' }
+                format.json { JSON::dump(:blob => @blob.to_hash(self)) }
               end
             else
               report_error(404)
@@ -161,7 +194,7 @@ module Deltacloud::Collections
             respond_to do |format|
               format.xml { haml :"blobs/show" }
               format.html { haml :"blobs/show"}
-              format.json { xml_to_json 'blobs/show' }
+              format.json { JSON::dump(:blob => @blob.to_hash(self)) }
             end
           end
         end
@@ -194,7 +227,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { xml_to_json 'blobs/show' }
+                format.json { JSON::dump(@blob.to_hash(self)) }
               end
             elsif(env["BLOB_FAIL"])
               report_error(500) #OK?
@@ -213,7 +246,7 @@ module Deltacloud::Collections
               respond_to do |format|
                 format.xml { haml :"blobs/show" }
                 format.html { haml :"blobs/show" }
-                format.json { xml_to_json 'blobs/show' }
+                format.json { JSON::dump(@blob.to_hash(self)) }
               end
             end
           end