opennebula-cli 3.8.0.beta1

data/lib/one_helper/onevm_helper.rb

@@ -0,0 +1,266 @@
+# -------------------------------------------------------------------------- #
+# 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 'one_helper'
+
+class OneVMHelper < OpenNebulaHelper::OneHelper
+    MULTIPLE={
+        :name  => "multiple",
+        :short => "-m x",
+        :large => "--multiple x",
+        :format => Integer,
+        :description => "Instance multiple VMs"
+    }
+
+    IMAGE = {
+        :name   => "image",
+        :short  => "-i id|name",
+        :large  => "--image id|name" ,
+        :description => "Selects the image",
+        :format => String,
+        :proc   => lambda { |o, options|
+            OpenNebulaHelper.rname_to_id(o, "IMAGE")
+        }
+    }
+
+    FILE = {
+        :name   => "file",
+        :short  => "-f file",
+        :large  => "--file file" ,
+        :description => "Selects the template file",
+        :format => String,
+        :proc   => lambda { |o, options|
+            if File.file?(o)
+                options[:file] = o
+            else
+                exit -1
+            end
+        }
+    }
+
+    def self.rname
+        "VM"
+    end
+
+    def self.conf_file
+        "onevm.yaml"
+    end
+
+    def self.state_to_str(id, lcm_id)
+        id = id.to_i
+        state_str = VirtualMachine::VM_STATE[id]
+        short_state_str = VirtualMachine::SHORT_VM_STATES[state_str]
+
+        if short_state_str=="actv"
+            lcm_id = lcm_id.to_i
+            lcm_state_str = VirtualMachine::LCM_STATE[lcm_id]
+            return VirtualMachine::SHORT_LCM_STATES[lcm_state_str]
+        end
+
+        return short_state_str
+    end
+
+    def format_pool(options)
+        config_file = self.class.table_conf
+
+        table = CLIHelper::ShowTable.new(config_file, self) do
+            column :ID, "ONE identifier for Virtual Machine", :size=>6 do |d|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the Virtual Machine", :left,
+                    :size=>15 do |d|
+                if d["RESCHED"] == "1"
+                    "*#{d["NAME"]}"
+                else
+                    d["NAME"]
+                end
+            end
+
+            column :USER, "Username of the Virtual Machine owner", :left,
+                    :size=>8 do |d|
+                helper.user_name(d, options)
+            end
+
+            column :GROUP, "Group of the Virtual Machine", :left,
+                    :size=>8 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :STAT, "Actual status", :size=>4 do |d,e|
+                OneVMHelper.state_to_str(d["STATE"], d["LCM_STATE"])
+            end
+
+            column :UCPU, "CPU percentage used by the VM", :size=>4 do |d|
+                d["CPU"]
+            end
+
+            column :UMEM, "Memory used by the VM", :size=>7 do |d|
+                OpenNebulaHelper.unit_to_str(d["MEMORY"].to_i, options)
+            end
+
+            column :HOST, "Host where the VM is running", :left, :size=>10 do |d|
+                if d['HISTORY_RECORDS'] && d['HISTORY_RECORDS']['HISTORY']
+                    state_str = VirtualMachine::VM_STATE[d['STATE'].to_i]
+                    if %w{ACTIVE SUSPENDED}.include? state_str
+                        d['HISTORY_RECORDS']['HISTORY']['HOSTNAME']
+                    end
+                end
+            end
+
+            column :TIME, "Time since the VM was submitted", :size=>10 do |d|
+                stime = d["STIME"].to_i
+                etime = d["ETIME"]=="0" ? Time.now.to_i : d["ETIME"].to_i
+                dtime = etime-stime
+                OpenNebulaHelper.period_to_str(dtime, false)
+            end
+
+            default :ID, :USER, :GROUP, :NAME, :STAT, :UCPU, :UMEM, :HOST,
+                :TIME
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::VirtualMachine.new_with_id(id, @client)
+        else
+            xml=OpenNebula::VirtualMachine.build_xml
+            OpenNebula::VirtualMachine.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        OpenNebula::VirtualMachinePool.new(@client, user_flag)
+    end
+
+    def format_resource(vm)
+        str_h1="%-80s"
+        str="%-20s: %-20s"
+
+        CLIHelper.print_header(
+            str_h1 % "VIRTUAL MACHINE #{vm['ID']} INFORMATION")
+        puts str % ["ID", vm.id.to_s]
+        puts str % ["NAME", vm.name]
+        puts str % ["USER", vm['UNAME']]
+        puts str % ["GROUP", vm['GNAME']]
+        puts str % ["STATE", vm.state_str]
+        puts str % ["LCM_STATE", vm.lcm_state_str]
+        puts str % ["RESCHED", OpenNebulaHelper.boolean_to_str(vm['RESCHED'])]
+        puts str % ["HOST",
+            vm['/VM/HISTORY_RECORDS/HISTORY[last()]/HOSTNAME']] if
+                %w{ACTIVE SUSPENDED}.include? vm.state_str
+        puts str % ["START TIME",
+            OpenNebulaHelper.time_to_str(vm['/VM/STIME'])]
+        puts str % ["END TIME",
+            OpenNebulaHelper.time_to_str(vm['/VM/ETIME'])]
+        value=vm['DEPLOY_ID']
+        puts str % ["DEPLOY ID", value=="" ? "-" : value]
+
+        puts
+
+        CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE MONITORING",false)
+        poll_attrs = {
+            "USED MEMORY" => "MEMORY",
+            "USED CPU" => "CPU",
+            "NET_TX" => "NET_TX",
+            "NET_RX" => "NET_RX"
+        }
+
+        poll_attrs.each { |k,v|
+            if k == "USED CPU"
+                puts str % [k,vm[v]]
+            elsif k == "USED MEMORY"
+                puts str % [k, OpenNebulaHelper.unit_to_str(vm[v].to_i, {})]
+            else
+                puts str % [k, OpenNebulaHelper.unit_to_str(vm[v].to_i/1024, {})]
+            end
+        }
+        puts
+
+        CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
+
+        ["OWNER", "GROUP", "OTHER"].each { |e|
+            mask = "---"
+            mask[0] = "u" if vm["PERMISSIONS/#{e}_U"] == "1"
+            mask[1] = "m" if vm["PERMISSIONS/#{e}_M"] == "1"
+            mask[2] = "a" if vm["PERMISSIONS/#{e}_A"] == "1"
+
+            puts str % [e,  mask]
+        }
+        puts
+
+        CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE TEMPLATE",false)
+        puts vm.template_str
+
+        if vm.has_elements?("/VM/HISTORY_RECORDS")
+            puts
+
+
+            CLIHelper.print_header(str_h1 % "VIRTUAL MACHINE HISTORY",false)
+            format_history(vm)
+        end
+    end
+
+    def format_history(vm)
+        table=CLIHelper::ShowTable.new(nil, self) do
+            column :SEQ, "Sequence number", :size=>4 do |d|
+                d["SEQ"]
+            end
+
+            column :HOST, "Host name of the VM container", :left, :size=>15 do |d|
+                d["HOSTNAME"]
+            end
+
+            column :REASON, "VM state change reason", :left, :size=>6 do |d|
+                VirtualMachine.get_reason d["REASON"]
+            end
+
+            column :START, "Time when the state changed", :size=>15 do |d|
+                OpenNebulaHelper.time_to_str(d['STIME'])
+            end
+
+            column :TIME, "Total time in this state", :size=>15 do |d|
+                stime = d["STIME"].to_i
+                etime = d["ETIME"]=="0" ? Time.now.to_i : d["ETIME"].to_i
+                dtime = etime-stime
+                OpenNebulaHelper.period_to_str(dtime)
+            end
+
+            column :PROLOG_TIME, "Prolog time for this state", :size=>15 do |d|
+                stime = d["PSTIME"].to_i
+                if d["PSTIME"]=="0"
+                    etime=0
+                else
+                    etime = d["PETIME"]=="0" ? Time.now.to_i: d["PETIME"].to_i
+                end
+                dtime = etime-stime
+                OpenNebulaHelper.period_to_str(dtime)
+            end
+
+            default :SEQ, :HOST, :REASON, :START, :TIME, :PROLOG_TIME
+        end
+
+        vm_hash=vm.to_hash
+
+        history=[vm_hash['VM']['HISTORY_RECORDS']['HISTORY']].flatten
+
+        table.show(history)
+    end
+end

data/lib/one_helper/onevnet_helper.rb

@@ -0,0 +1,156 @@
+# -------------------------------------------------------------------------- #
+# 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 'one_helper'
+
+class OneVNetHelper < OpenNebulaHelper::OneHelper
+    def self.rname
+        "VNET"
+    end
+
+    def self.conf_file
+        "onevnet.yaml"
+    end
+
+    def self.type_to_str(id)
+        id = id.to_i
+        type_str = VirtualNetwork::VN_TYPES[id]
+        return VirtualNetwork::SHORT_VN_TYPES[type_str]
+    end
+
+    def format_pool(options)
+        config_file = self.class.table_conf
+
+        table = CLIHelper::ShowTable.new(config_file, self) do
+            column :ID, "ONE identifier for Virtual Network", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :USER, "Username of the Virtual Network owner", :left,
+                    :size=>12 do |d|
+                helper.user_name(d, options)
+            end
+
+            column :GROUP, "Group of the Virtual Network", :left,
+                    :size=>12 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :NAME, "Name of the Virtual Network", :left,
+                    :size=>15 do |d|
+                d["NAME"]
+            end
+
+            column :CLUSTER, "Name of the Cluster", :left, :size=>10 do |d|
+                OpenNebulaHelper.cluster_str(d["CLUSTER"])
+            end 
+
+            column :TYPE, "Type of Virtual Network", :size=>6 do |d|
+                OneVNetHelper.type_to_str(d["TYPE"])
+            end
+
+            column :SIZE, "Size of the Virtual Network", :size=>5 do |d|
+                d["SIZE"]
+            end
+
+            column :BRIDGE, "Bridge associated to the Virtual Network", :left,
+                    :size=>8 do |d|
+                d["BRIDGE"]
+            end
+
+            column :LEASES, "Number of this Virtual Network's given leases",
+                    :size=>6 do |d|
+                d["TOTAL_LEASES"]
+            end
+
+            default :ID, :USER, :GROUP, :NAME, :CLUSTER, :TYPE, :BRIDGE, :LEASES
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::VirtualNetwork.new_with_id(id, @client)
+        else
+            xml=OpenNebula::VirtualNetwork.build_xml
+            OpenNebula::VirtualNetwork.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        OpenNebula::VirtualNetworkPool.new(@client, user_flag)
+    end
+
+    def format_resource(vn)
+        str_h1="%-80s"
+        CLIHelper.print_header(str_h1 %
+            ["VIRTUAL NETWORK #{vn.id.to_s} INFORMATION"])
+
+        str="%-15s: %-20s"
+        puts str % ["ID", vn.id.to_s]
+        puts str % ["NAME", vn['NAME']]
+        puts str % ["USER", vn['UNAME']]
+        puts str % ["GROUP", vn['GNAME']]
+        puts str % ["CLUSTER", OpenNebulaHelper.cluster_str(vn['CLUSTER'])]
+        puts str % ["TYPE", vn.type_str]
+        puts str % ["BRIDGE", vn["BRIDGE"]]
+        puts str % ["VLAN", OpenNebulaHelper.boolean_to_str(vn['VLAN'])]
+        puts str % ["PHYSICAL DEVICE", vn["PHYDEV"]] if vn["PHYDEV"]
+        puts str % ["VLAN ID", vn["VLAN_ID"]] if vn["VLAN_ID"]
+        puts str % ["USED LEASES", vn['TOTAL_LEASES']]
+        puts
+
+        CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
+
+        ["OWNER", "GROUP", "OTHER"].each { |e|
+            mask = "---"
+            mask[0] = "u" if vn["PERMISSIONS/#{e}_U"] == "1"
+            mask[1] = "m" if vn["PERMISSIONS/#{e}_M"] == "1"
+            mask[2] = "a" if vn["PERMISSIONS/#{e}_A"] == "1"
+
+            puts str % [e,  mask]
+        }
+        puts
+
+        CLIHelper.print_header(str_h1 % ["VIRTUAL NETWORK TEMPLATE"], false)
+
+        puts vn.template_str(false)
+
+        if vn.type_str == "RANGED"
+            puts
+            CLIHelper.print_header(str_h1 % ["RANGE"], false)
+            puts str % ["IP_START", vn['RANGE/IP_START']]
+            puts str % ["IP_END", vn['RANGE/IP_END']]
+        end
+
+        lease_types = [ ["LEASES ON HOLD",  'LEASE[USED=1 and VID=-1]'],
+                        ["USED LEASES",     'LEASE[USED=1 and VID>-1]'],
+                        ["FREE LEASES",     'LEASE[USED=0]'] ]
+
+        lease_types.each { |pair|
+            leases_str = vn.template_like_str('/VNET/LEASES', false, pair[1])
+
+            if !leases_str.empty?
+                puts
+                CLIHelper.print_header(str_h1 % [pair[0]], false)
+                puts leases_str
+            end
+        }
+    end
+end

data/lib/one_helper.rb

@@ -0,0 +1,609 @@
+# -------------------------------------------------------------------------- #
+# 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 'cli_helper'
+
+require 'OpenNebula'
+include OpenNebula
+
+module OpenNebulaHelper
+    ONE_VERSION=<<-EOT
+OpenNebula #{OpenNebula::VERSION}
+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
+EOT
+
+    if ONE_LOCATION
+        TABLE_CONF_PATH=ONE_LOCATION+"/etc/cli"
+    else
+        TABLE_CONF_PATH="/etc/one/cli"
+    end
+
+    EDITOR_PATH='/usr/bin/vi'
+
+    ########################################################################
+    # Options
+    ########################################################################
+    XML={
+        :name  => "xml",
+        :short => "-x",
+        :large => "--xml",
+        :description => "Show the resource in xml format"
+    }
+
+    NUMERIC={
+        :name  => "numeric",
+        :short => "-n",
+        :large => "--numeric",
+        :description => "Do not translate user and group IDs"
+    }
+
+    KILOBYTES={
+        :name  => "kilobytes",
+        :short => "-k",
+        :large => "--kilobytes",
+        :description => "Show units in kilobytes"
+    }
+
+    DESCRIBE={
+        :name  => "describe",
+        :large => "--describe",
+        :description => "Describe list columns"
+    }
+
+    # Command line VM template options
+    TEMPLATE_NAME_VM={
+        :name   => 'name',
+        :large  => '--name name',
+        :description =>
+            'Name for the new VM',
+        :format => String
+    }
+
+    TEMPLATE_OPTIONS=[
+        {
+            :name   => 'cpu',
+            :large  => '--cpu cpu',
+            :description =>
+                'CPU percentage reserved for the VM (1=100% one CPU)',
+            :format => Float
+        },
+        {
+            :name   => 'arch',
+            :large  => '--arch arch',
+            :description =>
+                'Architecture of the VM, e.g.: i386 or x86_64',
+            :format => String
+        },
+        {
+            :name   => 'memory',
+            :large  => '--memory memory',
+            :description => 'Memory ammount given to the VM',
+            :format => String,
+            :proc   => lambda do |o,options|
+                m=o.strip.match(/^(\d+(?:\.\d+)?)(m|mb|g|gb)?$/i)
+
+                if !m
+                    [-1, 'Memory value malformed']
+                else
+                    multiplier=case m[2]
+                    when /(g|gb)/i
+                        1024
+                    else
+                        1
+                    end
+
+                    value=m[1].to_f*multiplier
+
+                    [0, value.floor]
+                end
+            end
+        },
+        {
+            :name   => 'disk',
+            :large  => '--disk disk0,disk1',
+            :description => 'Disks to attach. To use a disk owned by other user use user[disk]',
+            :format => Array
+        },
+        {
+            :name   => 'network',
+            :large  => '--network network0,network1',
+            :description => 'Networks to attach. To use a network owned by other user use user[network]',
+            :format => Array
+        },
+        {
+            :name   => 'raw',
+            :large  => '--raw string',
+            :description => 'Raw string to add to the template. Not to be confused with the RAW attribute',
+            :format => String
+        }
+    ]
+
+    TEMPLATE_OPTIONS_VM=[TEMPLATE_NAME_VM]+TEMPLATE_OPTIONS
+
+    OPTIONS = XML, NUMERIC, KILOBYTES
+
+    class OneHelper
+        def initialize(secret=nil, endpoint=nil)
+            begin
+                @client = OpenNebula::Client.new(secret,endpoint)
+            rescue Exception => e
+                puts e.message
+                exit -1
+            end
+
+            @translation_hash = nil
+        end
+
+        def create_resource(options, &block)
+            resource = factory
+
+            rc = block.call(resource)
+            if OpenNebula.is_error?(rc)
+                return -1, rc.message
+            else
+                puts "ID: #{resource.id.to_s}"
+                return 0
+            end
+        end
+
+        def list_pool(options, top=false, filter_flag=nil)
+            if options[:describe]
+                table = format_pool(options)
+
+                table.describe_columns
+                return 0
+            end
+
+            filter_flag ||= OpenNebula::Pool::INFO_ALL
+
+            pool = factory_pool(filter_flag)
+
+            rc = pool.info
+            return -1, rc.message if OpenNebula.is_error?(rc)
+
+            if options[:xml]
+                return 0, pool.to_xml(true)
+            else
+                table = format_pool(options)
+
+                if top
+                    table.top(options) {
+                        pool.info
+                        pool_to_array(pool)
+                    }
+                else
+                    table.show(pool_to_array(pool), options)
+                end
+
+                return 0
+            end
+        end
+
+        def show_resource(id, options)
+            resource = retrieve_resource(id)
+
+            rc = resource.info
+            return -1, rc.message if OpenNebula.is_error?(rc)
+
+            if options[:xml]
+                return 0, resource.to_xml(true)
+            else
+                format_resource(resource)
+                return 0
+            end
+        end
+
+        def perform_action(id, options, verbose, &block)
+            resource = retrieve_resource(id)
+
+            rc = block.call(resource)
+            if OpenNebula.is_error?(rc)
+                return -1, rc.message
+            else
+                if options[:verbose]
+                    puts "#{self.class.rname} #{id}: #{verbose}"
+                end
+                return 0
+            end
+        end
+
+        def perform_actions(ids,options,verbose,&block)
+            exit_code = 0
+            ids.each do |id|
+                rc = perform_action(id,options,verbose,&block)
+
+                unless rc[0]==0
+                    puts rc[1]
+                    exit_code=rc[0]
+                end
+            end
+
+            exit_code
+        end
+
+        ########################################################################
+        # Id translation
+        ########################################################################
+        def user_name(resource, options={})
+            if options[:numeric]
+                resource['UID']
+            else
+                resource['UNAME']
+            end
+        end
+
+        def group_name(resource, options={})
+            if options[:numeric]
+                resource['GID']
+            else
+                resource['GNAME']
+            end
+        end
+
+        ########################################################################
+        # Formatters for arguments
+        ########################################################################
+        def to_id(name)
+            return 0, name.to_i if name.match(/^[0123456789]+$/)
+
+            rc = get_pool
+            return rc if rc.first != 0
+
+            pool     = rc[1]
+            poolname = self.class.rname
+
+            OneHelper.name_to_id(name, pool, poolname)
+        end
+
+        def self.to_id_desc
+            "OpenNebula #{self.rname} name or id"
+        end
+
+        def list_to_id(names)
+            rc = get_pool
+            return rc if rc.first != 0
+
+            pool     = rc[1]
+            poolname = self.class.rname
+
+            result = names.split(',').collect { |name|
+                if name.match(/^[0123456789]+$/)
+                    name.to_i
+                else
+                    rc = OneHelper.name_to_id(name, pool, poolname)
+
+                    if rc.first == -1
+                        return rc[0], rc[1]
+                    end
+
+                    rc[1]
+                end
+            }
+
+            return 0, result
+        end
+
+        def self.list_to_id_desc
+            "Comma-separated list of OpenNebula #{self.rname} names or ids"
+        end
+
+        def self.name_to_id(name, pool, ename)
+            objects=pool.select {|object| object.name==name }
+
+            if objects.length>0
+                if objects.length>1
+                    return -1, "There are multiple #{ename}s with name #{name}."
+                else
+                    result = objects.first.id
+                end
+            else
+                return -1, "#{ename} named #{name} not found."
+            end
+
+            return 0, result
+        end
+
+        def filterflag_to_i(str)
+            filter_flag = case str
+            when "a", "all"   then OpenNebula::Pool::INFO_ALL
+            when "m", "mine"  then OpenNebula::Pool::INFO_MINE
+            when "g", "group" then OpenNebula::Pool::INFO_GROUP
+            else
+                if str.match(/^[0123456789]+$/)
+                    str.to_i
+                else
+                    rc = OpenNebulaHelper.rname_to_id(str, "USER")
+                    if rc.first==-1
+                        return rc
+                    else
+                        rc[1]
+                    end
+                end
+            end
+
+            return 0, filter_flag
+        end
+
+        def self.filterflag_to_i_desc
+            desc=<<-EOT
+a, all       all the known #{self.rname}s
+m, mine      the #{self.rname} belonging to the user in ONE_AUTH
+g, group     'mine' plus the #{self.rname} belonging to the groups
+             the user is member of
+uid          #{self.rname} of the user identified by this uid
+user         #{self.rname} of the user identified by the username
+EOT
+        end
+
+        def self.table_conf
+            path = "#{ENV["HOME"]}/.one/cli/#{self.conf_file}"
+
+            if File.exists?(path)
+                return path
+            else
+                return "#{TABLE_CONF_PATH}/#{self.conf_file}"
+            end
+        end
+
+        private
+
+        def retrieve_resource(id)
+            factory(id)
+        end
+
+        def pool_to_array(pool)
+    	    if !pool.instance_of?(Hash)
+                phash = pool.to_hash
+            else
+                phash = pool
+            end
+
+            rname = self.class.rname
+
+            if phash["#{rname}_POOL"] &&
+                    phash["#{rname}_POOL"]["#{rname}"]
+                if phash["#{rname}_POOL"]["#{rname}"].instance_of?(Array)
+                    phash = phash["#{rname}_POOL"]["#{rname}"]
+                else
+                    phash = [phash["#{rname}_POOL"]["#{rname}"]]
+                end
+            else
+                phash = Array.new
+            end
+
+            phash
+        end
+
+        def get_pool
+            user_flag = OpenNebula::Pool::INFO_ALL
+            pool = factory_pool(user_flag)
+
+            rc = pool.info
+            if OpenNebula.is_error?(rc)
+                return -1, "OpenNebula #{self.class.rname} name not " <<
+                           "found, use the ID instead"
+            end
+
+            return 0, pool
+        end
+    end
+
+    def OpenNebulaHelper.rname_to_id(name, poolname)
+        return 0, name.to_i if name.match(/^[0123456789]+$/)
+
+        client = OpenNebula::Client.new
+
+        pool = case poolname
+        when "HOST"      then OpenNebula::HostPool.new(client)
+        when "GROUP"     then OpenNebula::GroupPool.new(client)
+        when "USER"      then OpenNebula::UserPool.new(client)
+        when "DATASTORE" then OpenNebula::DatastorePool.new(client)
+        when "CLUSTER"   then OpenNebula::ClusterPool.new(client)
+        when "VNET"      then OpenNebula::VirtualNetworkPool.new(client)
+        when "IMAGE"     then OpenNebula::ImagePool.new(client)
+        when "VMTEMPLATE" then OpenNebula::TemplatePool.new(client)
+        when "VM"        then OpenNebula::VirtualMachinePool.new(client)
+        end
+
+        rc = pool.info
+        if OpenNebula.is_error?(rc)
+            return -1, "OpenNebula #{poolname} name not found," <<
+                       " use the ID instead"
+        end
+
+        OneHelper.name_to_id(name, pool, poolname)
+    end
+
+    def OpenNebulaHelper.rname_to_id_desc(poolname)
+        "OpenNebula #{poolname} name or id"
+    end
+
+    def OpenNebulaHelper.boolean_to_str(str)
+        if str.to_i == 1
+            "Yes"
+        else
+            "No"
+        end
+    end
+
+    def OpenNebulaHelper.time_to_str(time)
+        value=time.to_i
+        if value==0
+            value='-'
+        else
+            value=Time.at(value).strftime("%m/%d %H:%M:%S")
+        end
+    end
+
+    def OpenNebulaHelper.period_to_str(time, print_seconds=true)
+        seconds=time.to_i
+        minutes, seconds=seconds.divmod(60)
+        hours, minutes=minutes.divmod(60)
+        days, hours=hours.divmod(24)
+
+        if print_seconds
+            "%3dd %02dh%02dm%02ds" % [days, hours, minutes, seconds]
+        else
+            "%3dd %02dh%02dm" % [days, hours, minutes]
+        end
+    end
+
+    BinarySufix = ["K", "M", "G", "T" ]
+
+    def OpenNebulaHelper.unit_to_str(value, options, unit="K")
+        if options[:kilobytes]
+            value
+        else
+            i=BinarySufix.index(unit).to_i
+
+            while value > 1024 && i < 3 do
+                value /= 1024.0
+                i+=1
+            end
+
+            value = (value * 10).round / 10.0
+
+            value = value.to_i if value - value.round == 0
+            st = value.to_s + BinarySufix[i]
+        end
+    end
+
+    # If the cluster name is empty, returns a '-' char.
+    #
+    # @param str [String || Hash] Cluster name, or empty Hash (when <CLUSTER/>)
+    # @return [String] the same Cluster name, or '-' if it is empty
+    def OpenNebulaHelper.cluster_str(str)
+        if str != nil && !str.empty?
+            str
+        else
+            "-"
+        end
+    end
+
+    def OpenNebulaHelper.update_template(id, resource, path=nil)
+        unless path
+            require 'tempfile'
+
+            tmp  = Tempfile.new(id.to_s)
+            path = tmp.path
+
+            rc = resource.info
+
+            if OpenNebula.is_error?(rc)
+                puts rc.message
+                exit -1
+            end
+
+            tmp << resource.template_str
+            tmp.flush
+
+            editor_path = ENV["EDITOR"] ? ENV["EDITOR"] : EDITOR_PATH
+            system("#{editor_path} #{path}")
+
+            unless $?.exitstatus == 0
+                puts "Editor not defined"
+                exit -1
+            end
+
+            tmp.close
+        end
+
+        str = File.read(path)
+        str
+    end
+
+    def self.parse_user_object(user_object)
+        reg=/^([^\[]+)(?:\[([^\]]+)\])?$/
+
+        m=user_object.match(reg)
+
+        return nil if !m
+
+        user=nil
+        if m[2]
+            user=m[1]
+            object=m[2]
+        else
+            object=m[1]
+        end
+
+        [user, object]
+    end
+
+    def self.create_disk_net(objects, section, name)
+        template=''
+
+        objects.each do |obj|
+            res=parse_user_object(obj)
+            return [-1, "#{section.capitalize} \"#{obj}\" malformed"] if !res
+            user, object=*res
+
+            template<<"#{section.upcase}=[\n"
+            template<<"  #{name.upcase}_UNAME=\"#{user}\",\n" if user
+            if object.match(/^\d$/)
+                template<<"  #{name.upcase}_ID=#{object}\n"
+            else
+                template<<"  #{name.upcase}=\"#{object}\"\n"
+            end
+            template<<"]\n"
+        end if objects
+
+        [0, template]
+    end
+
+    def self.create_template(options)
+        template=''
+
+        template<<"NAME=\"#{options[:name]}\"\n" if options[:name]
+        template<<"OS = [ ARCH = \"#{options[:arch]}\" ]\n" if options[:arch]
+        template<<"CPU=#{options[:cpu]}\n" if options[:cpu]
+        template<<"MEMORY=#{options[:memory]}\n" if options[:memory]
+        template<<"#{options[:raw]}\n" if options[:raw]
+
+        if options[:disk]
+            res=create_disk_net(options[:disk], 'DISK', 'IMAGE')
+            return res if res.first!=0
+
+            template<<res.last
+        end
+
+        if options[:network]
+            res=create_disk_net(options[:network], 'NIC', 'NETWORK')
+            return res if res.first!=0
+
+            template<<res.last
+        end
+
+
+        [0, template]
+    end
+
+    def self.create_template_options_used?(options)
+        # Get the template options names as symbols. options hash
+        # uses symbols
+        template_options=OpenNebulaHelper::TEMPLATE_OPTIONS.map do |o|
+            o[:name].to_sym
+        end
+
+        # Check if one at least one of the template options is
+        # in options hash
+        (template_options-options.keys)!=template_options
+    end
+end