occi 2.0.0 → 2.0.1

data/lib/OpenNebula/VirtualNetworkPool.rb

@@ -1,74 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
-#                                                                            #
-# 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.                                             #
-#--------------------------------------------------------------------------- #
-
-
-require 'OpenNebula/Pool'
-
-module OpenNebula
-    class VirtualNetworkPool < Pool
-        #######################################################################
-        # Constants and Class attribute accessors
-        #######################################################################
-
-
-        VN_POOL_METHODS = {
-            :info => "vnpool.info"
-        }
-
-        #######################################################################
-        # Class constructor & Pool Methods
-        #######################################################################
-
-        # +client+ a Client object that represents a XML-RPC connection
-        # +user_id+ is to refer to a Pool with VirtualNetworks from that user
-        def initialize(client, user_id=0)
-            super('VNET_POOL','VNET',client)
-
-            @user_id  = user_id
-        end
-
-        # Default Factory Method for the Pools
-        def factory(element_xml)
-            OpenNebula::VirtualNetwork.new(element_xml,@client)
-        end
-
-        #######################################################################
-        # XML-RPC Methods for the Virtual Network Object
-        #######################################################################
-
-        # Retrieves all or part of the VirtualMachines in the pool.
-        def info(*args)
-            case args.size
-                when 0
-                    info_filter(VN_POOL_METHODS[:info],@user_id,-1,-1)
-                when 3
-                    info_filter(VN_POOL_METHODS[:info],args[0],args[1],args[2])
-            end
-        end
-
-        def info_all()
-            return super(VN_POOL_METHODS[:info])
-        end
-
-        def info_mine()
-            return super(VN_POOL_METHODS[:info])
-        end
-
-        def info_group()
-            return super(VN_POOL_METHODS[:info])
-        end
-    end
-end

data/lib/OpenNebula/XMLUtils.rb

@@ -1,337 +0,0 @@
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
-#                                                                            #
-# 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.                                             #
-#--------------------------------------------------------------------------- #
-
-
-module OpenNebula
-
-    begin
-        require 'nokogiri'
-        NOKOGIRI=true
-    rescue LoadError
-        NOKOGIRI=false
-    end
-
-    begin
-        require 'rexml/formatters/pretty'
-        REXML_FORMATTERS=true
-    rescue LoadError
-        REXML_FORMATTERS=false
-    end
-
-    # The XMLElement class provides an abstraction of the underlying
-    # XML parser engine. It provides XML-related methods for the Pool and
-    # PoolElement classes
-    class XMLElement
-
-        # xml:: _opaque xml object_ an xml object as returned by build_xml
-        def initialize(xml=nil)
-            @xml = xml
-        end
-
-        # Initialize a XML document for the element
-        # xml:: _String_ the XML document of the object
-        # root_element:: _String_ Base xml element
-        def initialize_xml(xml, root_element)
-            @xml = XMLElement.build_xml(xml, root_element)
-
-            if OpenNebula.is_error?(@xml)
-                @xml = nil
-            else
-                if NOKOGIRI
-                    if @xml.size == 0
-                        @xml = nil
-                    end
-                else
-                    if @xml.name != root_element
-                        @xml = nil
-                    end
-                end
-            end
-        end
-
-        # Builds a XML document
-        # xml:: _String_ the XML document of the object
-        # root_element:: _String_ Base xml element
-        # [return] _XML_ object for the underlying XML engine
-        def self.build_xml(xml, root_element)
-            begin
-                if NOKOGIRI
-                    doc = Nokogiri::XML(xml).xpath("/#{root_element}")
-                else
-                    doc = REXML::Document.new(xml).root
-                end
-            rescue Exception => e
-                return OpenNebula::Error.new(e.message)
-            end
-
-            return doc
-        end
-        # Extract an element from the XML description of the PoolElement.
-        # key::_String_ The name of the element
-        # [return] _String_ the value of the element
-        # Examples:
-        #   ['VID'] # gets VM id
-        #   ['HISTORY/HOSTNAME'] # get the hostname from the history
-        def [](key)
-            if NOKOGIRI
-                element=@xml.xpath(key.to_s)
-
-                if element.size == 0
-                    return nil
-                end
-            else
-                element=@xml.elements[key.to_s]
-            end
-
-            if element
-                element.text
-            end
-        end
-
-        # Gets an array of text from elemenets extracted
-        # using  the XPATH  expression passed as filter
-        def retrieve_elements(filter)
-            elements_array = Array.new
-
-            if NOKOGIRI
-                @xml.xpath(filter.to_s).each { |pelem|
-                    elements_array << pelem.text if pelem.text
-                 }
-            else
-                @xml.elements.each(filter.to_s) { |pelem|
-                    elements_array << pelem.text if pelem.text
-                }
-            end
-
-            if elements_array.size == 0
-                return nil
-            else
-                return elements_array
-            end
-
-        end
-
-        # Gets an attribute from an elemenT
-        # key:: _String_ xpath for the element
-        # name:: _String_ name of the attribute
-        def attr(key,name)
-            value = nil
-
-            if NOKOGIRI
-                element=@xml.xpath(key.to_s.upcase)
-                if element.size == 0
-                    return nil
-                end
-
-                attribute = element.attr(name)
-
-                value = attribute.text if attribute != nil
-            else
-                element=@xml.elements[key.to_s.upcase]
-
-                value = element.attributes[name] if element != nil
-            end
-
-            return value
-        end
-
-        # Iterates over every Element in the XPath and calls the block with a
-        # a XMLElement
-        # block:: _Block_
-        def each(xpath_str,&block)
-            if NOKOGIRI
-                @xml.xpath(xpath_str).each { |pelem|
-                    block.call XMLElement.new(pelem)
-                }
-            else
-                @xml.elements.each(xpath_str) { |pelem|
-                    block.call XMLElement.new(pelem)
-                }
-            end
-        end
-
-        def each_xpath(xpath_str,&block)
-            if NOKOGIRI
-                @xml.xpath(xpath_str).each { |pelem|
-                    block.call pelem.text
-                }
-            else
-                @xml.elements.each(xpath_str) { |pelem|
-                    block.call pelem.text
-                }
-            end
-        end
-
-        def name
-            @xml.name
-        end
-
-        def text
-            if NOKOGIRI
-                @xml.content
-            else
-                @xml.text
-            end
-        end
-
-        def has_elements?(xpath_str)
-            if NOKOGIRI
-                element = @xml.xpath(xpath_str.to_s.upcase)
-                return element != nil && element.children.size > 0
-            else
-                element = @xml.elements[xpath_str.to_s]
-                return element != nil && element.has_elements?
-            end
-        end
-
-        def template_str(indent=true)
-            template_like_str('TEMPLATE', indent)
-        end
-
-        def template_like_str(root_element, indent=true, xpath_exp=nil)
-            if NOKOGIRI
-                xml_template=@xml.xpath(root_element).to_s
-                rexml=REXML::Document.new(xml_template).root
-            else
-                rexml=@xml.elements[root_element]
-            end
-
-            if indent
-                ind_enter="\n"
-                ind_tab='  '
-            else
-                ind_enter=''
-                ind_tab=' '
-            end
-
-            str=rexml.elements.collect(xpath_exp) {|n|
-                if n.class==REXML::Element
-                    str_line=""
-                    if n.has_elements?
-                        str_line << n.name << "=[" << ind_enter
-
-                        str_line << n.collect {|n2|
-                            if n2 && n2.class==REXML::Element
-                                str = ""
-                                str << ind_tab << n2.name << '='
-                                str << attr_to_str(n2.text) if n2.text
-                                str
-                            end
-                        }.compact.join(','+ind_enter)
-                        str_line<<" ]"
-                    else
-                        str_line << n.name << '=' << attr_to_str(n.text.to_s)
-                    end
-                    str_line
-                end
-            }.compact.join("\n")
-
-            str
-        end
-
-        def to_xml(pretty=false)
-            if NOKOGIRI && pretty
-                str = @xml.to_xml
-            elsif REXML_FORMATTERS && pretty
-                str = String.new
-
-                formatter = REXML::Formatters::Pretty.new
-                formatter.compact = true
-
-                formatter.write(@xml,str)
-            else
-                str = @xml.to_s
-            end
-
-            return str
-        end
-
-        def to_hash(hash={}, element=nil)
-            element ||= @xml.document.root
-
-            if NOKOGIRI
-                array = element.children
-                if array.length==1 and (array.first.text? or array.first.cdata?)
-                    r = array.first.text
-                else
-                    r = {}
-                    array.each { |c|
-                        if c.element?
-                            to_hash(r, c)
-                        end
-                    }
-                end
-            else
-                r = {}
-                if element.has_elements?
-                    element.each_element { |c| to_hash(r, c) }
-                elsif element.has_text?
-                    r = element.text
-                end
-            end
-
-            key = element.name
-            if hash.has_key?(key)
-                if hash[key].instance_of?(Array)
-                    hash[key] << r
-                else
-                    hash[key] = [hash[key], r]
-                end
-            else
-                hash[key] = r
-            end
-
-            hash
-        end
-
-    private
-        def attr_to_str(attr)
-            attr.gsub!('"',"\\\"")
-
-            if attr.match(/[=,' ']/)
-                return '"' + attr + '"'
-            end
-
-            return attr
-        end
-    end
-
-    # The XMLUtilsPool module provides an abstraction of the underlying
-    # XML parser engine. It provides XML-related methods for the Pools
-    class XMLPool < XMLElement
-
-        def initialize(xml=nil)
-            super(xml)
-        end
-
-        #Executes the given block for each element of the Pool
-        #block:: _Block_
-        def each_element(block)
-            if NOKOGIRI
-                @xml.xpath(
-                    "#{@element_name}").each {|pelem|
-                    block.call self.factory(pelem)
-                }
-            else
-                @xml.elements.each(
-                    "#{@element_name}") {|pelem|
-                    block.call self.factory(pelem)
-                }
-            end
-        end
-    end
-
-end

data/lib/occi/configuration.rb

@@ -1,118 +0,0 @@
-##############################################################################
-#  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