deltacloud-core 1.1.1 → 1.1.2

data/lib/cimi/models/volume.rb

@@ -51,24 +51,6 @@ class CIMI::Model::Volume < CIMI::Model::Base
 
   def self.all(context); find(:all, context); end
 
-  def self.create(request_body, context, type)
-    #json = JSON.parse(json_in)
-    input = (type == :xml)? XmlSimple.xml_in(request_body, {"ForceArray"=>false,"NormaliseSpace"=>2}) : JSON.parse(request_body)
-    if input["volumeTemplate"]["href"]  #template by reference
-      #FIXME - don't have volumeTemplates yet - datamapper   volume_config =
-    else #template by value
-      volume_image_id = (input["volumeTemplate"].has_key?("volumeImage") ?
-                input["volumeTemplate"]["volumeImage"]["href"].split("/").last  : nil)
-      if input["volumeTemplate"]["volumeConfig"]["href"] #with config by reference
-        volume_config_id = input["volumeTemplate"]["volumeConfig"]["href"].split("/").last
-        create_volume({:volume_config_id=>volume_config_id, :volume_image_id=>volume_image_id}, input, context)
-      else #with config by value
-        capacity = input["volumeTemplate"]["volumeConfig"]["capacity"]
-        create_volume({:capacity=>capacity, :volume_image_id=>volume_image_id}, input, context)
-      end
-    end
-  end
-
   def self.delete!(id, context)
     context.driver.destroy_storage_volume(context.credentials, {:id=>id} )
     new(:id => id).destroy
@@ -77,35 +59,13 @@ class CIMI::Model::Volume < CIMI::Model::Base
   def self.find_to_attach_from_json(json_in, context)
     json = JSON.parse(json_in)
     json["volumes"].map{|v| {:volume=>self.find(v["volume"]["href"].split("/volumes/").last, context),
-                             :attachment_point=>v["attachmentPoint"]  }}
+                             :initial_location=>v["initialLocation"]  }}
   end
 
   def self.find_to_attach_from_xml(xml_in, context)
     xml = XmlSimple.xml_in(xml_in)
     xml["volume"].map{|v| {:volume => self.find(v["href"].split("/volumes/").last, context),
-                           :attachment_point=>v["attachmentPoint"] }}
-  end
-
-  private
-
-  def self.create_volume(params, data, context)
-    if params[:volume_config_id]
-      volume_config = CIMI::Model::VolumeConfiguration.find(params[:volume_config_id], context)
-      opts = {:capacity=>context.from_kibibyte(volume_config.capacity, "GB"),
-              :snapshot_id=>params[:volume_image_id],
-              :name=>data["name"]}
-    elsif params[:capacity]
-      opts = {:capacity=>context.from_kibibyte(params[:capacity], "GB"),
-              :snapshot_id=>params[:volume_image_id],
-              :name=>data["name"]}
-    end
-    storage_volume = context.driver.create_storage_volume(context.credentials, opts)
-    result = from_storage_volume(storage_volume, context)
-    result.name = data['name'] if data['name']
-    result.description = data['description']
-    result.extract_properties!(data)
-    result.save
-    result
+                           :initial_location=>v["initialLocation"] }}
   end
 
   def self.from_storage_volume(volume, context)

data/lib/cimi/models/volume_configuration.rb

@@ -17,9 +17,9 @@ class CIMI::Model::VolumeConfiguration < CIMI::Model::Base
 
   acts_as_root_entity :as => "volumeConfigs"
 
+  href :type
   text :format
-
-  text :capacity
+  text :capacity, :required => true
 
   array :operations do
     scalar :rel, :href
@@ -32,7 +32,7 @@ class CIMI::Model::VolumeConfiguration < CIMI::Model::Base
       :description => json['description'],
       :format => json['format'],
       :capacity => json['capacity'],
-      :ent_properties => json['properties'] ? json['properties'].to_json : {}
+      :ent_properties => (json['properties'] || {}).to_json
     )
     from_db(new_config, context)
   end
@@ -45,7 +45,7 @@ class CIMI::Model::VolumeConfiguration < CIMI::Model::Base
       :description => xml['description'].first,
       :format => xml['format'].first,
       :capacity => xml['capacity'].first,
-      :ent_properties => xml['property'] ? JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r }) : {}
+      :ent_properties =>  JSON::dump((xml['property'] || {}).inject({}){ |r, p| r[p['key']]=p['content']; r })
     )
     from_db(new_config, context)
   end

data/lib/cimi/models/volume_create.rb

@@ -0,0 +1,58 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+class CIMI::Model::VolumeCreate < CIMI::Model::Base
+
+  ref :volume_template, :required => true
+
+  def create(context)
+    validate!
+
+    if volume_template.href?
+      template = volume_template.find(context)
+    else
+      template = CIMI::Model::VolumeTemplate.from_xml(volume_template.to_xml)
+    end
+
+    volume_image = template.volume_image.href? ?
+      template.volume_image.find(context) : template.volume_image
+
+    volume_config = template.volume_config.href? ?
+      template.volume_config.find(context) : template.volume_config
+
+    params = {
+      :name => name,
+      :capacity => volume_config.capacity,
+      :snapshot_id => ref_id(volume_image.id),
+    }
+
+    unless context.driver.respond_to? :create_storage_volume
+       raise Deltacloud::Exceptions.exception_from_status(
+         501,
+         "Creating Volume is not supported by the current driver"
+       )
+    end
+
+    volume = context.driver.create_storage_volume(context.credentials, params)
+
+    result = CIMI::Model::Volume.from_storage_volume(volume, context)
+    result.name = name if result.name.nil?
+    result.description = description if description
+    result.property = property if property
+    result.save
+    result
+  end
+
+end

data/lib/cimi/models/volume_image.rb

@@ -20,6 +20,7 @@ class CIMI::Model::VolumeImage < CIMI::Model::Base
   href :image_location
   text :image_data
   text :bootable
+
   array :operations do
     scalar :rel, :href
   end
@@ -38,29 +39,19 @@ class CIMI::Model::VolumeImage < CIMI::Model::Base
 
   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.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
-            } )
+      :name => snapshot.name,
+      :description => snapshot.description,
+      :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
+    } )
   end
 
 end

data/lib/cimi/models/volume_image_create.rb

@@ -0,0 +1,47 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+class CIMI::Model::VolumeImageCreate < CIMI::Model::Base
+
+  href :image_location
+  text :image_data
+  text :bootable, :required => true
+
+  def create(context)
+    validate!
+
+    params = {
+      :volume_id => context.href_id(image_location.href, :volumes),
+      :name => name,
+      :description => description
+    }
+
+    unless context.driver.respond_to? :create_storage_snapshot
+      raise Deltacloud::Exceptions.exception_from_status(
+        501,
+        'Creating VolumeImage is not supported by the current driver'
+      )
+    end
+
+    new_snapshot = context.driver.create_storage_snapshot(context.credentials, params)
+    result = CIMI::Model::VolumeImage.from_storage_snapshot(new_snapshot, context)
+    result.name= name unless new_snapshot.name
+    result.description = description unless new_snapshot.description
+    result.property = property if property
+    result.save
+    result
+  end
+
+end

data/lib/cimi/models/volume_template.rb

@@ -17,8 +17,8 @@ class CIMI::Model::VolumeTemplate < CIMI::Model::Base
 
   acts_as_root_entity
 
-  href :volume_config
-  href :volume_image
+  ref :volume_config, :required => true
+  ref :volume_image, :required => true
 
   array :meter_templates do
   end
@@ -47,26 +47,10 @@ class CIMI::Model::VolumeTemplate < CIMI::Model::Base
     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 => input['property'] ? 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),
@@ -76,7 +60,10 @@ private
       :volume_image => {:href => model.volume_image},
       :property => (model.ent_properties ? JSON::parse(model.ent_properties) :  nil),
       :operations => [
-        { :href => context.destroy_volume_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+        {
+          :href => context.destroy_volume_template_url(model.id),
+          :rel => 'http://schemas.dmtf.org/cimi/1/action/delete'
+        }
       ]
     )
   end

data/lib/cimi/models/volume_template_create.rb

@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+class CIMI::Model::VolumeTemplateCreate < CIMI::Model::Base
+
+  ref :volume_config, :required => true
+  ref :volume_image, :required => true
+
+  def create(context)
+    validate!
+    new_template = self.class.current_db.add_volume_template(
+      :name => name,
+      :description => description,
+      :volume_config => volume_config.href,
+      :volume_image => volume_image.href,
+      :ent_properties => property.to_json
+    )
+    CIMI::Model::VolumeTemplate.from_db(new_template, context)
+  end
+
+end

data/lib/db.rb

@@ -15,31 +15,23 @@
 
 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')
+  def self.connect(location)
+    if ENV['API_VERBOSE']
+      if Deltacloud.respond_to? :config
+        logger = Deltacloud.config[:cimi].logger
+      else
+        logger = ::Logger.new($stdout)
+      end
+    end
+    @db =  Sequel.connect(location, :logger => logger)
   end
 
-  def self.database(opts={})
-    opts[:logger] = ::Logger.new($stdout) if ENV['API_VERBOSE']
-    @db ||=  Sequel.connect(DATABASE_LOCATION, opts)
+  def self.database
+    @db
   end
 
-  def self.initialize_database
-    db = database
+  def self.initialize_database(location)
+    db = connect(location)
 
     db.create_table?(:providers) {
       primary_key :id
@@ -92,6 +84,6 @@ module Deltacloud
       column :volume_config, :string
       column :volume_image, :string
     }
+    db
   end
-
 end

data/lib/db/volume_template.rb

@@ -18,7 +18,7 @@ module Deltacloud
 
     class VolumeTemplate < Entity
       validates_presence_of :volume_config
-      validates_presence_of :volume_Image
+      validates_presence_of :volume_image
     end
 
   end

data/lib/deltacloud/api.rb

@@ -39,7 +39,7 @@ module TestPoller
     opts[:retries] ||= 10
     opts[:time_between_retry] ||= 10
     opts[:timeout] ||= 60
-    opts[:method] ||= self.class.name.downcase.to_sym
+    opts[:method] ||= self.class.name.split('::').last.downcase.to_sym
     opts[:retries].downto(0) do |r|
       result = begin
         timeout(opts[:timeout]) do
@@ -62,12 +62,13 @@ module TestPoller
   end
 end
 
-class Instance; include TestPoller; end
-class Image; include TestPoller; end
-class StorageSnapshot; include TestPoller; end
-
 module Deltacloud
 
+  class Instance; include TestPoller; end
+  class Image; include TestPoller; end
+  class StorageSnapshot; include TestPoller; end
+
+
   def self.drivers
     Drivers.driver_config
   end

data/lib/deltacloud/collections.rb

@@ -15,41 +15,18 @@
 # under the License.
 
 require_relative './collections/base'
+require_relative './helpers/collection_helper'
 
 module Deltacloud
 
-  def self.collection_names
-    @collections.map { |c| c.collection_name }
-  end
-
-  def self.collections
-    @collections ||= []
-  end
-
   module Collections
+    extend Deltacloud::CollectionHelper
 
-    def self.collection(name)
-      Deltacloud.collections.find { |c| c.collection_name == name }
-    end
-
-    def self.deltacloud_modules
-      @deltacloud_modules ||= []
-    end
-
-    Dir[File.join(File::dirname(__FILE__), "collections", "*.rb")].each do |collection|
-      base_collection_name = File.basename(collection).gsub('.rb', '')
-      next if base_collection_name == 'base'
-      require collection
-      deltacloud_module_class = Deltacloud::Collections.const_get(base_collection_name.camelize)
-      deltacloud_modules << deltacloud_module_class
-      deltacloud_module_class.collections.each do |c|
-        Deltacloud.collections << c
-      end unless deltacloud_module_class.collections.nil?
-    end
+    load_collections_for :deltacloud, :from => File.join(File.dirname(__FILE__), 'collections')
 
     def self.included(klass)
       klass.class_eval do
-        Deltacloud::Collections.deltacloud_modules.each do |collection_class|
+        Deltacloud::Collections.modules(:deltacloud).each do |collection_class|
           use collection_class
         end
       end