deltacloud-core 1.1.1 → 1.1.2

data/lib/cimi/models/cloud_entry_point.rb

@@ -51,7 +51,7 @@ class CIMI::Model::CloudEntryPoint < CIMI::Model::Base
 
   # Return an Hash of the CIMI root entities used in CloudEntryPoint
   def self.entities(context)
-    CIMI::Collections.cimi_modules.inject({}) do |supported_entities, m|
+    CIMI::Collections.modules(:cimi).inject({}) do |supported_entities, m|
       m.collections.each do |c|
         index_operation_capability = c.operation(:index).required_capability
         next if m.settings.respond_to?(:capability) and !m.settings.capability(index_operation_capability)

data/lib/cimi/models/credential.rb

@@ -17,7 +17,7 @@ class CIMI::Model::Credential < CIMI::Model::Base
 
   acts_as_root_entity
 
-  text :username
+  text :username, :password, :key
   text :password
   text :key
 

data/lib/cimi/models/credential_create.rb

@@ -0,0 +1,46 @@
+# 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::CredentialCreate < CIMI::Model::Base
+
+  ref :credential_template, :required => true
+
+  def create(context)
+    validate!
+
+    unless context.driver.respond_to? :create_key
+       raise Deltacloud::Exceptions.exception_from_status(
+         501,
+         "Creating Credential is not supported by the current driver"
+       )
+    end
+
+    if credential_template.href?
+      template = credential_template.find(ctx)
+    else
+      template = credential_template
+    end
+
+    key = context.driver.create_key(context.credentials, :key_name => name)
+
+    result = CIMI::Model::Credential.from_key(key, context)
+    result.name = name if name
+    result.description = description if description
+    result.property = property if property
+    result.save
+    result
+
+  end
+end

data/lib/cimi/models/credential_template.rb

@@ -0,0 +1,24 @@
+# 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::CredentialTemplate < CIMI::Model::Base
+
+  text :username, :required => true
+  text :password, :required => true
+  text :key, :required => true
+
+  # TODO: tbd
+
+end

data/lib/cimi/models/machine.rb

@@ -50,75 +50,6 @@ class CIMI::Model::Machine < CIMI::Model::Base
     end
   end
 
-  def self.create_from_json(body, context)
-    json = JSON.parse(body)
-    additional_params={}
-    machine_template = json['machineTemplate']
-    if !machine_template['href'].nil?
-      template = current_db.machine_templates.first(:id => machine_template['href'].split('/').last)
-      raise 'Could not find the MachineTemplate' if template.nil?
-      hardware_profile_id = template.machine_config.split('/').last
-      image_id = template.machine_image.split('/').last
-    else
-      hardware_profile_id = machine_template['machineConfig']["href"].split('/').last
-      image_id = machine_template['machineImage']["href"].split('/').last
-      if machine_template.has_key? 'credential'
-        additional_params[:keyname] = machine_template['credential']["href"].split('/').last
-      end
-    end
-    if machine_template.has_key? "initialState"
-      additional_params[:initial_state] = machine_template["initialState"].strip
-    end
-    additional_params[:name] = json['name'] if json['name']
-    additional_params[:realm_id] = json['realm'] if json['realm']
-    instance = context.driver.create_instance(context.credentials, image_id, {
-      :hwp_id => hardware_profile_id
-    }.merge(additional_params))
-
-    # Store attributes that are not supported by the backend cloud to local
-    # database:
-    machine = from_instance(instance, context)
-    machine.name = json['name'] || machine.name
-    machine.description = json['description']
-    machine.extract_properties!(json)
-    machine.save
-    machine
-  end
-
-  def self.create_from_xml(body, context)
-    xml = XmlSimple.xml_in(body)
-    additional_params = {}
-    if xml['machineTemplate'][0]['href']
-      template = current_db.machine_templates_dataset.first(:id => xml['machineTemplate'][0]['href'].split('/').last)
-      hardware_profile_id = template.machine_config.split('/').last
-      image_id = template.machine_image.split('/').last
-    else
-      machine_template = xml['machineTemplate'][0]
-      hardware_profile_id = machine_template['machineConfig'].first["href"].split('/').last
-      image_id = machine_template['machineImage'].first["href"].split('/').last
-      if machine_template.has_key? 'credential'
-        additional_params[:keyname] = machine_template['credential'][0]["href"].split('/').last
-      end
-    end
-    if xml["machineTemplate"][0].has_key? "initialState"
-      additional_params[:initial_state] = xml["machineTemplate"][0]["initialState"].first.strip
-    end
-    additional_params[:name] = xml['name'][0] if xml['name']
-    additional_params[:realm_id] = xml['realm'][0] if xml['realm']
-    instance = context.driver.create_instance(context.credentials, image_id, {
-      :hwp_id => hardware_profile_id
-    }.merge(additional_params))
-
-    # Store attributes that are not supported by the backend cloud to local
-    # database:
-    machine = from_instance(instance, context)
-    machine.name = xml['name'] || machine.name
-    machine.description = xml['description']
-    machine.extract_properties!(xml)
-    machine.save
-    machine
-  end
-
   def perform(action, context, &block)
     begin
       if context.driver.send(:"#{action.name}_instance", context.credentials, self.id.split("/").last)
@@ -150,7 +81,6 @@ class CIMI::Model::Machine < CIMI::Model::Base
     CIMI::Model::MachineVolume.collection_for_instance(context.params[:id], context)
   end
 
-  private
   def self.from_instance(instance, context)
     cpu =  memory = (instance.instance_profile.id == "opaque")? "n/a" : nil
     machine_conf = CIMI::Model::MachineConfiguration.find(instance.instance_profile.name, context)
@@ -230,7 +160,7 @@ class CIMI::Model::Machine < CIMI::Model::Base
   def self.convert_storage_volumes(instance, context)
     instance.storage_volumes ||= [] #deal with nilpointers
     instance.storage_volumes.map{|vol| {:href=>context.volume_url(vol.keys.first),
-                                       :attachment_point=>vol.values.first} }
+                                       :initial_location=>vol.values.first} }
   end
 
 end

data/lib/cimi/models/machine_configuration.rb

@@ -17,13 +17,13 @@ class CIMI::Model::MachineConfiguration < CIMI::Model::Base
 
   acts_as_root_entity :as => "machineConfigs"
 
-  text :cpu
-  text :memory
+  text :cpu, :required => true
+  text :memory, :required => true
 
   array :disks do
     text :capacity
     text :format
-    text :attachment_point
+    text :initial_location
   end
 
   array :operations do

data/lib/cimi/models/machine_create.rb

@@ -0,0 +1,49 @@
+# 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::MachineCreate < CIMI::Model::Base
+  ref :machine_template
+  text :realm
+
+  def create(ctx)
+    params = {}
+    if machine_template.href
+      template = machine_template.find(ctx)
+      params[:hwp_id] = template.machine_config.ref_id(ctx)
+      params[:initial_state] = template.initial_state
+      image_id = template.machine_image.ref_id(ctx)
+    else
+      # FIXME: What if either of these href's isn't there ? What if the user
+      # tries to override some aspect of the machine_config/machine_image ?
+      params[:hwp_id] = machine_template.machine_config.href.split('/').last
+      params[:initial_state] = machine_template.initial_state
+      image_id = machine_template.machine_image.href.split('/').last
+      if machine_template.credential.href
+        params[:keyname] = machine_template.credential.href.split('/').last
+      end
+    end
+
+    params[:name] = name if name
+    params[:realm_id] = realm if realm
+    instance = ctx.driver.create_instance(ctx.credentials, image_id, params)
+
+    result = CIMI::Model::Machine::from_instance(instance, ctx)
+    result.name = name if name
+    result.description = description if description
+    result.property = property if property
+    result.save
+    result
+  end
+end

data/lib/cimi/models/machine_image.rb

@@ -44,34 +44,11 @@ class CIMI::Model::MachineImage < CIMI::Model::Base
       :description => image.description,
       :state => image.state || 'UNKNOWN',
       :type => "IMAGE",
-      :created => image.creation_time.nil? ? Time.now.xmlschema : Time.parse(image.creation_time.to_s).xmlschema
+      :created => image.creation_time.nil? ?
+        Time.now.xmlschema : Time.parse(image.creation_time.to_s).xmlschema
     )
   end
 
-  def self.create(request_body, context)
-    # The 'imageLocation' attribute is mandatory in CIMI, however in Deltacloud
-    # there is no way how to figure out from what Machine the MachineImage was
-    # created from. For that we need to store this attribute in properties.
-    #
-    if context.grab_content_type(context.request.content_type, request_body) == :xml
-      input = XmlSimple.xml_in(request_body.read, {"ForceArray"=>false,"NormaliseSpace"=>2})
-      raise 'imageLocation attribute is mandatory' unless input['imageLocation']
-      input['property'] ||= {}
-    else
-      input = JSON.parse(request_body.read)
-      raise 'imageLocation attribute is mandatory' unless input['imageLocation']
-      input['properties'] ||= []
-    end
-    params = {:id => context.href_id(input["imageLocation"], :machines), :name=>input["name"], :description=>input["description"]}
-    image = context.driver.create_image(context.credentials, params)
-    result = from_image(image, context)
-    result.name = input['name'] if input['name']
-    result.description = input['description'] if input['description']
-    result.extract_properties!(input)
-    result.save
-    result
-  end
-
   def self.delete!(image_id, context)
     context.driver.destroy_image(context.credentials, image_id)
     new(:id => image_id).destroy

data/lib/cimi/models/machine_image_create.rb

@@ -0,0 +1,41 @@
+# 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::MachineImageCreate < CIMI::Model::Base
+
+  text :type, :required => true
+  text :image_location, :required => true
+  href :related_image
+
+  def create(context)
+    validate!
+
+    params = {
+      :id => context.href_id(image_location, :machines),
+      :name => name,
+      :description => description
+    }
+
+    img = context.driver.create_image(context.credentials, params)
+
+    result = CIMI::Model::MachineImage.from_image(img, context)
+    result.name = name if name
+    result.description = description if description
+    result.property = property if property
+    result.save
+    result
+  end
+
+end

data/lib/cimi/models/machine_template.rb

@@ -17,18 +17,20 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
 
   acts_as_root_entity
 
-  href :machine_config
-  href :machine_image
-  href :credential
+  text :initial_state
+  ref :machine_config
+  ref :machine_image
+  ref :credential
+
+  resource_attr :realm, :required => false,
+    :constraints => lambda { |c| c.driver.realms(c.credentials).map { |r| r.id }}
 
   array :volumes do
-    scalar :href
-    scalar :protocol
-    scalar :attachment_point
+    scalar :href, :initial_location
   end
 
   array :volume_templates do
-    scalar :href, :attachment_point, :protocol
+    scalar :href, :initial_location
   end
 
   array :network_interfaces do
@@ -52,36 +54,10 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
       end
     end
 
-    def create_from_json(body, context)
-      json = JSON.parse(body)
-      new_template = current_db.add_machine_template(
-        :name => json['name'],
-        :description => json['description'],
-        :machine_config => json['machineConfig']['href'],
-        :machine_image => json['machineImage']['href'],
-        :ent_properties => json['properties'] ? json['properties'].to_json : {}
-      )
-      from_db(new_template, context)
-    end
-
-    def create_from_xml(body, context)
-      xml = XmlSimple.xml_in(body)
-      new_template = current_db.add_machine_template(
-        :name => xml['name'].first,
-        :description => xml['description'].first,
-        :machine_config => xml['machineConfig'].first['href'],
-        :machine_image => xml['machineImage'].first['href'],
-        :ent_properties => xml['property'] ? JSON::dump(xml['property'].inject({}) { |r, p| r[p['key']]=p['content']; r }) : {}
-      )
-      from_db(new_template, context)
-    end
-
     def delete!(id, context)
       current_db.machine_templates.first(:id => id).destroy
     end
 
-    private
-
     def from_db(model, context)
       self.new(
         :id => context.machine_template_url(model.id),
@@ -89,10 +65,14 @@ class CIMI::Model::MachineTemplate < CIMI::Model::Base
         :description => model.description,
         :machine_config => { :href => model.machine_config },
         :machine_image => { :href => model.machine_image },
+        :realm => model.realm,
         :property => (model.ent_properties ? JSON::parse(model.ent_properties) :  nil),
         :created => Time.parse(model.created_at.to_s).xmlschema,
         :operations => [
-          { :href => context.destroy_machine_template_url(model.id), :rel => 'http://schemas.dmtf.org/cimi/1/action/delete' }
+          {
+            :href => context.destroy_machine_template_url(model.id),
+            :rel => 'http://schemas.dmtf.org/cimi/1/action/delete'
+          }
         ]
       )
     end

data/lib/cimi/models/machine_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::MachineTemplateCreate < CIMI::Model::Base
+
+  href :machine_config, :required => true
+  href :machine_image, :required => true
+
+  def create(context)
+    validate!
+    new_template = self.class.current_db.add_machine_template(
+      :name => name,
+      :description => description,
+      :machine_config => machine_config.href,
+      :machine_image => machine_image.href,
+      :ent_properties => property.to_json
+    )
+    CIMI::Model::MachineTemplate.from_db(new_template, context)
+  end
+
+end

data/lib/cimi/models/network.rb

@@ -52,25 +52,6 @@ class CIMI::Model::Network < CIMI::Model::Base
     networks
   end
 
-  def self.create(request_body, context, type)
-    input = (type == :xml)? XmlSimple.xml_in(request_body, {"ForceArray"=>false,"NormaliseSpace"=>2}) : JSON.parse(request_body)
-    if input["networkTemplate"]["href"] #template by reference
-      network_config, routing_group = get_by_reference(input, context)
-    else
-      if input["networkTemplate"]["networkConfig"]["href"] # configuration by reference
-        network_config = CIMI::Model::NetworkConfiguration.find(context.href_id(input["networkTemplate"]["networkConfig"]["href"],
-                                                                                :network_configurations), context)
-      else #configuration by value
-        network_config = get_by_value(request_body, type)
-      end
-      routing_group = CIMI::Model::RoutingGroup.find(context.href_id(input["networkTemplate"]["routingGroup"]["href"],
-                                                                     :routing_groups), context)
-    end
-    params = {:network_config => network_config, :routing_group => routing_group, :name=>input["name"],
-              :description=>input["description"], :env=>context}
-    raise CIMI::Model::BadRequest.new("Bad request - missing required parameters. Client sent: #{request_body} which produced #{params.inspect}")  if params.has_value?(nil)
-    context.driver.create_network(context.credentials, params)
-  end
 
   def self.delete!(id, context)
     context.driver.delete_network(context.credentials, id)
@@ -88,23 +69,4 @@ class CIMI::Model::Network < CIMI::Model::Base
     end
   end
 
-  private
-
-  def self.get_by_reference(input, context)
-    network_template = CIMI::Model::NetworkTemplate.find(context.href_id(input["networkTemplate"]["href"], :network_templates), context)
-    network_config = CIMI::Model::NetworkConfiguration.find(context.href_id(network_template.network_config.href, :network_configurations), context)
-    routing_group = CIMI::Model::RoutingGroup.find(context.href_id(network_template.routing_group.href, :routing_groups), context)
-    return network_config, routing_group
-  end
-
-  def self.get_by_value(request_body, type)
-    if type == :xml
-      xml_arrays = XmlSimple.xml_in(request_body, {"NormaliseSpace"=>2})
-      network_config = CIMI::Model::NetworkConfiguration.from_xml(XmlSimple.xml_out(xml_arrays["networkTemplate"][0]["networkConfig"][0]))
-    else
-     json = JSON.parse(request_body)
-      network_config = CIMI::Model::NetworkConfiguration.from_json(JSON.generate(json["networkTemplate"]["networkConfig"]))
-    end
-  end
-
 end