occi 1.2.1 → 2.0.0

data/lib/occi/configuration.rb

@@ -0,0 +1,118 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#  
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: Configuration of OCCI Webservice
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'occi/log'
+
+module OCCI
+  class Configuration
+
+    ###########################################################################
+    # Mandatory config parameters
+
+    @@mandatory_params = []
+    # the backend needs to be specified, currently supported: dummy and opennebula
+    @@mandatory_params << "backend"
+    # the url of the server needs to be specified
+    @@mandatory_params << "server"
+    # the port of the server needs to be specified
+    @@mandatory_params << "port"
+
+    ###########################################################################
+    # Patterns to parse the Configuration File
+
+    NAME_REG     =/[\w\d_-]+/
+    VARIABLE_REG =/\s*(#{NAME_REG})\s*=\s*/
+
+    SIMPLE_VARIABLE_REG =/#{VARIABLE_REG}([^\[]+?)(#.*)?/
+    SINGLE_VARIABLE_REG =/^#{SIMPLE_VARIABLE_REG}$/
+    ARRAY_VARIABLE_REG  =/^#{VARIABLE_REG}\[(.*?)\]/m
+
+    ###########################################################################
+    def initialize(file)
+      @conf=parse_conf(file)
+    end
+
+    def add_configuration_value(key,value)
+      add_value(@conf,key,value)
+    end
+
+    def [](key)
+      @conf[key.to_s.upcase]
+    end
+
+    private
+
+    #
+    #
+    #
+    def add_value(conf, key, value)
+      if conf[key]
+        if !conf[key].kind_of?(Array)
+          conf[key]=[conf[key]]
+        end
+        conf[key]<<value
+      else
+        conf[key]=value
+      end
+    end
+
+    def check_params(conf)
+      @@mandatory_params.each do
+        |param|
+        if conf[param.upcase] == nil
+          raise "Mandatory parameter " + param + " not provided in config file. exiting"
+        end
+      end
+    end
+
+    def parse_conf(file)
+      conf_file=File.read(file)
+
+      conf=Hash.new
+
+      conf_file.scan(SINGLE_VARIABLE_REG) {|m|
+        key=m[0].strip.upcase
+        value=m[1].strip
+        
+        # hack to skip multiline VM_TYPE values
+        next if %w{NAME TEMPLATE}.include? key.upcase
+
+        add_value(conf, key, value)
+      }
+
+      conf_file.scan(ARRAY_VARIABLE_REG) {|m|
+        master_key=m[0].strip.upcase
+
+        pieces=m[1].split(',')
+
+        vars=Hash.new
+        pieces.each {|p|
+          key, value=p.split('=')
+          vars[key.strip.upcase]=value.strip
+        }
+
+        add_value(conf, master_key, vars)
+      }
+
+      conf
+    end
+  end
+end

data/lib/occi/core/action.rb

@@ -0,0 +1,29 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#  
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: OCCI Core Action
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'occi/core/category'
+
+module OCCI
+  module Core
+    class Action < OCCI::Core::Category
+    end
+  end
+end

data/lib/occi/core/attribute_properties.rb

@@ -0,0 +1,54 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: storing a single Attribute
+# Author(s): Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'hashie/mash'
+
+module OCCI
+  module Core
+    class AttributeProperties < Hashie::Mash
+
+      def initialize(attributes = nil, default = nil)
+        if attributes[:type] || attributes.required || attributes.mutable || attributes.pattern || attributes.minimum || attributes.maximum || attributes.description
+          attributes[:type] ||= "string"
+          attributes.required ||= false
+          attributes.mutable ||= false
+          attributes.pattern ||= ".*"
+        end unless attributes.nil?
+        super(attributes, default)
+      end
+
+      def combine
+        array = []
+        self.each_key do |key|
+          puts key
+          puts self[key]
+          if self[key].include? 'type'
+            array << key + "{}"
+          else
+            self[key].combine.each { |attr| array << key + '.' + attr }
+          end
+        end
+        return array
+      end
+
+    end
+  end
+end

data/lib/occi/core/attributes.rb

@@ -0,0 +1,40 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#  
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: storing a single Attribute
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+module OCCI
+  module Core
+    class Attributes < Hashie::Mash
+
+      def combine
+        hash = {}
+        self.each_key do |key|
+          if self[key].kind_of? Hashie::Mash
+            self[key].combine.each_pair { |k, v| hash[key + '.' + k] = v }
+          else
+            hash[key] = self[key]
+          end
+        end
+        return hash
+      end
+
+    end
+  end
+end

data/lib/occi/core/category.rb

@@ -0,0 +1,62 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: OCCI Core Category
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'json'
+require 'hashie/mash'
+
+module OCCI
+  module Core
+    class Category < Hashie::Mash
+
+      def initialize(category=nil, default = nil)
+        category.attributes = OCCI::Core::AttributeProperties.new(category.attributes) if category
+        super(category, default)
+      end
+
+      def convert_value(val, duping=false) #:nodoc:
+        case val
+          when self.class
+            val.dup
+          when ::Hash
+            val = val.dup if duping
+            self.class.subkey_class.new.merge(val) unless val.kind_of?(Hashie::Mash)
+            val
+          when Array
+            val.collect { |e| convert_value(e) }
+          else
+            val
+        end
+      end
+
+      def type_identifier
+        regular_reader("scheme") + regular_reader("term")
+      end
+
+      def related_to?(category_id)
+        self.related.each do |category|
+          return true if category.type_identifier == category_id || category.related_to?(category_id)
+        end if self.related
+        false
+      end
+
+    end
+  end
+end

data/lib/occi/core/collection.rb

@@ -0,0 +1,27 @@
+module OCCI
+  module Core
+    class Collection
+      attr_accessor :kinds
+      attr_accessor :mixins
+      attr_accessor :actions
+      attr_accessor :resources
+      attr_accessor :links
+
+      def initialize(kinds=[], mixins=[], actions=[], resources=[], links=[])
+        @kinds = kinds
+        @mixins = mixins
+        @actions = actions
+        @resources = resources
+        @links = links
+      end
+
+      def categories
+        @kinds + @mixins + @actions
+      end
+
+      def entities
+        @resources + @links
+      end
+    end
+  end
+end

data/lib/occi/core/entity.rb

@@ -0,0 +1,135 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#
+#  Licensed 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.
+##############################################################################
+
+##############################################################################
+# Description: OCCI Core Entity
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'rubygems'
+require 'uuidtools'
+require 'hashie'
+require 'occi/registry'
+require 'occi/core/attributes'
+require 'occi/core/kind'
+require 'occi/core/attribute_properties'
+
+module OCCI
+  module Core
+    class Entity < Hashie::Mash
+
+      # Define appropriate kind
+      def self.register
+        data = Hashie::Mash.new
+        data[:term] = "entity"
+        data[:scheme] = "http://schemas.ogf.org/occi/core#"
+        data[:title] = "Entity"
+        data.attributes!.occi!.core!.id!.type = "string"
+        data.attributes!.occi!.core!.id!.pattern = "[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}"
+        data.attributes!.occi!.core!.id!.required = false
+        data.attributes!.occi!.core!.id!.mutable = false
+        data.attributes!.occi!.core!.title!.type = "string"
+        data.attributes!.occi!.core!.title!.pattern = ".*"
+        data.attributes!.occi!.core!.title!.required = false
+        data.attributes!.occi!.core!.title!.mutable = true
+
+        kind = OCCI::Core::Kind.new(data)
+        OCCI::Registry.register(kind)
+      end
+
+      def initialize(entity=nil, default = nil)
+        super(entity, default)
+        self.check
+      end
+
+      def id
+        return self[:id]
+      end
+
+      def id=(id)
+        self[:id] = id
+        self.attributes!.occi!.core!.id = id
+      end
+
+      def title
+        return self[:title]
+      end
+
+      def title=(title)
+        self[:title] = title
+        self.attributes!.occi!.core!.title = title
+      end
+
+      def location
+        '/' + OCCI::Registry.get_by_id(self.kind).term + '/' + self.id if self.kind
+      end
+
+      def type_identifier
+        OCCI::Registry.get_by_id(self.kind).type_identifier
+      end
+
+      def check
+        definitions = OCCI::Registry.get_by_id(self.kind).attributes if self.kind
+        self.mixins.each { |mixin| definitions.merge!(OCCI::Registry.get_by_id(mixin).attributes) if OCCI::Registry.get_by_id(mixin).attributes } if self.mixins
+        self.attributes = Entity.check(self.attributes, definitions) if definitions
+      end
+
+      def self.check(attributes, definitions)
+        attributes = OCCI::Core::Attributes.new(attributes)
+        definitions.each_key do |key|
+          properties = definitions[key]
+          value = attributes[key] ||= properties[:default]
+          if properties.include?(:type)
+            raise "required attribute #{key} not found" if value.nil? && properties.required
+            next if value.nil? && !properties.required
+            case properties.type
+              when 'string'
+                raise "attribute #{key} with value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless value.kind_of?(String)
+                raise "attribute #{key} with length #{value.length} not in range #{properties.minimum}-#{properties.maximum}" unless (properties.minimum..properties.maximum) === value.length if properties.minimum && properties.maximum
+              when 'number'
+                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless value.kind_of?(Numeric)
+                raise "attribute #{key} with value #{value} not in range #{properties.minimum}-#{properties.maximum}" unless (properties.minimum..properties.maximum) === value if properties.minimum && properties.maximum
+              when 'boolean'
+                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless !!value == value
+            end
+            raise "attribute #{key} with value #{value} does not match pattern #{properties.pattern}" if value.to_s.scan(Regexp.new(properties.pattern)).empty? if properties.pattern
+            attributes[key] = value
+          else
+            attributes[key] = check(value, definitions[key])
+          end
+        end
+        attributes.delete_if { |k, v| v.nil? } # remove empty attributes
+        return attributes
+      end
+
+      def convert_value(val, duping=false) #:nodoc:
+        case val
+          when self.class
+            val.dup
+          when ::Hash
+            val = val.dup if duping
+            self.class.subkey_class.new.merge(val) unless val.kind_of?(Hashie::Mash)
+            val
+          when Array
+            val.collect { |e| convert_value(e) }
+          else
+            val
+        end
+      end
+
+    end
+  end
+end