opennebula-cli 3.8.0.beta1

data/lib/one_helper/onegroup_helper.rb

@@ -0,0 +1,134 @@
+# -------------------------------------------------------------------------- #
+# 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'
+require 'one_helper/onequota_helper'
+
+class OneGroupHelper < OpenNebulaHelper::OneHelper
+    def self.rname
+        "GROUP"
+    end
+
+    def self.conf_file
+        "onegroup.yaml"
+    end
+
+    def create_resource(options, &block)
+        group = factory
+
+        rc = block.call(group)
+        if OpenNebula.is_error?(rc)
+            return -1, rc.message
+        else
+            puts "ID: #{group.id.to_s}"
+        end
+
+        puts "Creating default ACL rules from #{GROUP_DEFAULT}" if options[:verbose]
+
+        exit_code , msg = group.create_acls
+
+        puts msg 
+
+        exit_code
+    end
+
+    def format_pool(options)
+        config_file = self.class.table_conf
+
+        table = CLIHelper::ShowTable.new(config_file, self) do
+            column :ID, "ONE identifier for the Group", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the Group", :left, :size=>29 do |d|
+                d["NAME"]
+            end
+
+            column :USERS, "Number of Users in this group", :size=>5 do |d|
+                if d["USERS"]["ID"].nil?
+                    "0"
+                else
+                    d["USERS"]["ID"].size
+                end
+            end
+
+            column :VMS , "Number of VMS", :size=>9 do |d|             
+                if d.has_key?('VM_QUOTA') and d['VM_QUOTA'].has_key?('VM')
+                    "%3d / %3d" % [d['VM_QUOTA']['VM']["VMS_USED"], d['VM_QUOTA']['VM']["VMS"]]
+                else
+                    "-"
+                end
+            end
+
+            column :MEMORY, "Total memory allocated to user VMs", :size=>17 do |d|
+                if d.has_key?('VM_QUOTA') and d['VM_QUOTA'].has_key?('VM')
+                    "%7s / %7s" % [OpenNebulaHelper.unit_to_str(d['VM_QUOTA']['VM']["MEMORY_USED"].to_i,{},"M"),
+                    OpenNebulaHelper.unit_to_str(d['VM_QUOTA']['VM']["MEMORY"].to_i,{},"M")]
+                else
+                    "-"
+                end
+            end
+
+            column :CPU, "Total CPU allocated to user VMs", :size=>11 do |d|
+                if d.has_key?('VM_QUOTA') and d['VM_QUOTA'].has_key?('VM')
+                    "%4.0f / %4.0f" % [d['VM_QUOTA']['VM']["CPU_USED"], d['VM_QUOTA']['VM']["CPU"]]
+                else
+                    "-"
+                end
+            end
+
+            default :ID, :NAME, :USERS, :VMS, :MEMORY, :CPU
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::Group.new_with_id(id, @client)
+        else
+            xml=OpenNebula::Group.build_xml
+            OpenNebula::Group.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        #TBD OpenNebula::UserPool.new(@client, user_flag)
+        OpenNebula::GroupPool.new(@client)
+    end
+
+    def format_resource(group)
+        str="%-15s: %-20s"
+        str_h1="%-80s"
+
+        CLIHelper.print_header(str_h1 % "GROUP #{group['ID']} INFORMATION")
+        puts str % ["ID",   group.id.to_s]
+        puts str % ["NAME", group.name]
+        puts
+
+        CLIHelper.print_header(str_h1 % "USERS", false)
+        CLIHelper.print_header("%-15s" % ["ID"])
+        group.user_ids.each do |uid|
+            puts "%-15s" % [uid]
+        end
+
+        group_hash = group.to_hash
+
+        OneQuotaHelper.format_quota(group_hash['GROUP'])
+    end
+end

data/lib/one_helper/onehost_helper.rb

@@ -0,0 +1,196 @@
+# -------------------------------------------------------------------------- #
+# 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 OneHostHelper < OpenNebulaHelper::OneHelper
+    def self.rname
+        "HOST"
+    end
+
+    def self.conf_file
+        "onehost.yaml"
+    end
+
+    def self.state_to_str(id)
+        id        = id.to_i
+        state_str = Host::HOST_STATES[id]
+        
+        return Host::SHORT_HOST_STATES[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 Host", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the Host", :left, :size=>15 do |d|
+                d["NAME"]
+            end
+
+            column :CLUSTER, "Name of the Cluster", :left, :size=>9 do |d|
+                OpenNebulaHelper.cluster_str(d["CLUSTER"])
+            end
+
+            column :RVM, "Number of Virtual Machines running", :size=>3 do |d|
+                d["HOST_SHARE"]["RUNNING_VMS"]
+            end
+
+            column :TCPU, "Total CPU percentage", :size=>4 do |d|
+                d["HOST_SHARE"]["MAX_CPU"]
+            end
+
+            column :FCPU, "Free CPU percentage", :size=>4 do |d|
+                d["HOST_SHARE"]["MAX_CPU"].to_i-
+                    d["HOST_SHARE"]["USED_CPU"].to_i
+            end
+
+            column :ACPU, "Available cpu percentage (not reserved by VMs)",
+                    :size=>4 do |d|
+                max_cpu=d["HOST_SHARE"]["MAX_CPU"].to_i
+                max_cpu=100 if max_cpu==0
+                max_cpu-d["HOST_SHARE"]["CPU_USAGE"].to_i
+            end
+
+            column :TMEM, "Total Memory", :size=>7 do |d|
+                OpenNebulaHelper.unit_to_str(
+                    d["HOST_SHARE"]["MAX_MEM"].to_i,
+                    options)
+            end
+
+            column :FMEM, "Free Memory", :size=>7 do |d|
+                OpenNebulaHelper.unit_to_str(
+                    d["HOST_SHARE"]["FREE_MEM"].to_i,
+                    options)
+            end
+
+            column :AMEM, "Available Memory (not reserved by VMs)",
+                    :size=>7 do |d|
+                acpu=d["HOST_SHARE"]["MAX_MEM"].to_i-
+                    d["HOST_SHARE"]["MEM_USAGE"].to_i
+                OpenNebulaHelper.unit_to_str(acpu,options)
+            end
+
+            column :REAL_CPU, "Real CPU", :size=>18 do |d|
+                max_cpu  = d["HOST_SHARE"]["MAX_CPU"].to_i
+
+                if max_cpu != 0
+                    used_cpu = d["HOST_SHARE"]["USED_CPU"].to_i
+                    ratio    = (used_cpu*100) / max_cpu
+                    "#{used_cpu} / #{max_cpu} (#{ratio}%)"
+                else
+                    '-'
+                end
+            end
+
+            column :ALLOCATED_CPU, "Allocated CPU)", :size=>18 do |d|
+                max_cpu  = d["HOST_SHARE"]["MAX_CPU"].to_i
+
+                if max_cpu != 0
+                    cpu_usage = d["HOST_SHARE"]["CPU_USAGE"].to_i
+                    ratio    = (cpu_usage*100) / max_cpu
+                    "#{cpu_usage} / #{max_cpu} (#{ratio}%)"
+                else
+                    '-'
+                end
+            end
+
+            column :REAL_MEM, "Real MEM", :size=>18 do |d|
+                max_mem  = d["HOST_SHARE"]["MAX_MEM"].to_i
+
+                if max_mem != 0
+                    used_mem = d["HOST_SHARE"]["USED_MEM"].to_i
+                    ratio    = (used_mem*100) / max_mem
+                    "#{OpenNebulaHelper.unit_to_str(used_mem,options)} / #{OpenNebulaHelper.unit_to_str(max_mem,options)} (#{ratio}%)"
+                else
+                    '-'
+                end
+            end
+
+            column :ALLOCATED_MEM, "Allocated MEM", :size=>18 do |d|
+                max_mem  = d["HOST_SHARE"]["MAX_MEM"].to_i
+
+                if max_mem != 0
+                    mem_usage = d["HOST_SHARE"]["MEM_USAGE"].to_i
+                    ratio    = (mem_usage*100) / max_mem
+                    "#{OpenNebulaHelper.unit_to_str(mem_usage,options)} / #{OpenNebulaHelper.unit_to_str(max_mem,options)} (#{ratio}%)"
+                else
+                    '-'
+                end
+            end
+
+            column :STAT, "Host status", :left, :size=>6 do |d|
+                OneHostHelper.state_to_str(d["STATE"])
+            end
+
+            default :ID, :NAME, :CLUSTER, :RVM, :ALLOCATED_CPU, :ALLOCATED_MEM, :STAT
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::Host.new_with_id(id, @client)
+        else
+            xml=OpenNebula::Host.build_xml
+            OpenNebula::Host.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        #TBD OpenNebula::HostPool.new(@client, user_flag)
+        OpenNebula::HostPool.new(@client)
+    end
+
+    def format_resource(host)
+        str    = "%-22s: %-20s"
+        str_h1 = "%-80s"
+
+        CLIHelper.print_header(
+            str_h1 % "HOST #{host.id.to_s} INFORMATION", true)
+
+        puts str % ["ID", host.id.to_s]
+        puts str % ["NAME", host.name]
+        puts str % ["CLUSTER", OpenNebulaHelper.cluster_str(host['CLUSTER'])]
+        puts str % ["STATE", host.state_str]
+        puts str % ["IM_MAD", host['IM_MAD']]
+        puts str % ["VM_MAD", host['VM_MAD']]
+        puts str % ["VN_MAD", host['VN_MAD']]
+        puts str % ["LAST MONITORING TIME", OpenNebulaHelper.time_to_str(host['LAST_MON_TIME'])]
+        puts
+
+        CLIHelper.print_header(str_h1 % "HOST SHARES", false)
+
+        puts str % ["TOTAL MEM", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MAX_MEM'].to_i, {})]
+        puts str % ["USED MEM (REAL)", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/USED_MEM'].to_i, {})]
+        puts str % ["USED MEM (ALLOCATED)", OpenNebulaHelper.unit_to_str(host['HOST_SHARE/MEM_USAGE'].to_i, {})]
+        puts str % ["TOTAL CPU", host['HOST_SHARE/MAX_CPU']]
+        puts str % ["USED CPU (REAL)", host['HOST_SHARE/USED_CPU']]
+        puts str % ["USED CPU (ALLOCATED)", host['HOST_SHARE/CPU_USAGE']]
+        puts str % ["RUNNING VMS", host['HOST_SHARE/RUNNING_VMS']]
+        puts
+
+        CLIHelper.print_header(str_h1 % "MONITORING INFORMATION", false)
+
+        puts host.template_str
+    end
+end

data/lib/one_helper/oneimage_helper.rb

@@ -0,0 +1,327 @@
+# -------------------------------------------------------------------------- #
+# 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 OneImageHelper < OpenNebulaHelper::OneHelper
+    TEMPLATE_OPTIONS=[
+        {
+            :name => "name",
+            :large => "--name name",
+            :format => String,
+            :description => "Name of the new image"
+        },
+        {
+            :name => "description",
+            :large => "--description description",
+            :format => String,
+            :description => "Description for the new Image"
+        },
+        {
+            :name => "type",
+            :large => "--type type",
+            :format => String,
+            :description => "Type of the new Image: OS, CDROM or DATABLOCK",
+            :proc => lambda do |o, options|
+                type=o.strip.upcase
+
+                if %w{OS CDROM DATABLOCK}.include? type
+                    [0, type]
+                else
+                    [-1, "Type should be OS, CDROM or DATABLOCK"]
+                end
+            end
+        },
+        {
+            :name => "persistent",
+            :large => "--persistent",
+            :description => "Tells if the image will be persistent"
+        },
+        {
+            :name => "prefix",
+            :large => "--prefix prefix",
+            :description => "Device prefix for the disk (eg. hd, sd, xvd or vd)",
+            :format => String,
+            :proc => lambda do |o, options|
+                prefix=o.strip.downcase
+                if %w{hd sd xvd vd}.include? prefix
+                    [0, prefix]
+                else
+                    [-1, "The prefix must be hd, sd, xvd or vd"]
+                end
+            end
+        },
+        {
+            :name => "target",
+            :large => "--target target",
+            :description => "Device the disk will be attached to",
+            :format => String
+        },
+        {
+            :name => "path",
+            :large => "--path path",
+            :description => "Path of the image file",
+            :format => String,
+            :proc => lambda do |o, options|
+                if o[0,1]=='/'
+                    path=o
+                else
+                    path=Dir.pwd+"/"+o
+                end
+
+                if File.exist?(path)
+                    [0, path]
+                else
+                    [-1, "File '#{path}' does not exist."]
+                end
+            end
+        },
+        {
+            :name => "driver",
+            :large => "--driver driver",
+            :description => "Driver to use image (raw, qcow2, tap:aio:...)",
+            :format => String
+        },
+        {
+            :name => "disk_type",
+            :large => "--disk_type disk_type",
+            :description => "Type of the image (BLOCK, CDROM or FILE)",
+            :format => String,
+            :proc => lambda do |o, options|
+                type=o.strip.upcase
+                if %w{BLOCK CDROM FILE}.include? type
+                    [0, type]
+                else
+                    [-1, "Disk type must be BLOCK, CDROM or FILE"]
+                end
+            end
+        },
+        {
+            :name => "source",
+            :large => "--source source",
+            :description =>
+                "Source to be used. Useful for not file-based images",
+            :format => String
+        },
+        {
+            :name => "size",
+            :large => "--size size",
+            :description => "Size in MB. Used for DATABLOCK type",
+            :format => String,
+            :proc => lambda do |o, options|
+                if !options[:type] || !(options[:type].upcase=='DATABLOCK')
+                    next [-1, "Size is only used for DATABLOCK type images"]
+                end
+
+                m=o.strip.match(/^(\d+(?:\.\d+)?)(m|mb|g|gb)?$/i)
+
+                if !m
+                    [-1, 'Size 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 => "fstype",
+            :large => "--fstype fstype",
+            :description => "Type of file system to be built. This can be "<<
+                "any value understood by mkfs unix command.",
+            :format => String,
+            :proc => lambda do |o, options|
+                if !options[:type] || !(options[:type].upcase=='DATABLOCK')
+                    [-1, "FSTYPE is only used for DATABLOCK type images"]
+                else
+                    [0, o]
+                end
+            end
+        }
+    ]
+
+    def self.rname
+        "IMAGE"
+    end
+
+    def self.conf_file
+        "oneimage.yaml"
+    end
+
+    def self.state_to_str(id)
+        id = id.to_i
+        state_str = Image::IMAGE_STATES[id]
+        return Image::SHORT_IMAGE_STATES[state_str]
+    end
+
+    def self.type_to_str(id)
+        id = id.to_i
+        type_str = Image::IMAGE_TYPES[id]
+        return Image::SHORT_IMAGE_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 the Image", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :USER, "Username of the Image owner", :left,
+                    :size=>10 do |d|
+                helper.user_name(d, options)
+            end
+
+            column :GROUP, "Group of the Image", :left,
+                    :size=>10 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :NAME, "Name of the Image", :left, :size=>15 do |d|
+                d["NAME"]
+            end
+
+            column :DATASTORE, "Name of the Datastore", :left, :size=>10 do |d|
+                d["DATASTORE"]
+            end
+
+            column :TYPE, "Type of the Image", :left, :size=>4 do |d,e|
+                OneImageHelper.type_to_str(d["TYPE"])
+            end
+
+            column :REGTIME, "Registration time of the Image",
+                    :size=>15 do |d|
+                OpenNebulaHelper.time_to_str(d["REGTIME"])
+            end
+
+            column :PERSISTENT, "Whether the Image is persistent or not",
+                    :size=>3 do |d|
+                OpenNebulaHelper.boolean_to_str(d["PERSISTENT"])
+            end
+
+            column :STAT, "State of the Image", :left, :size=>4 do |d|
+                OneImageHelper.state_to_str(d["STATE"])
+            end
+
+            column :RVMS, "Number of VMs currently running from this Image",
+                    :size=>4 do |d|
+                d['RUNNING_VMS']
+            end
+
+            column :SIZE, "Size of the image",
+                    :size=>7 do |d|
+                OpenNebulaHelper.unit_to_str(d['SIZE'].to_i,options,"M")
+            end
+
+            default :ID, :USER, :GROUP, :NAME, :DATASTORE, :SIZE, :TYPE,
+                :PERSISTENT , :STAT, :RVMS
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::Image.new_with_id(id, @client)
+        else
+            xml=OpenNebula::Image.build_xml
+            OpenNebula::Image.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        OpenNebula::ImagePool.new(@client, user_flag)
+    end
+
+    def format_resource(image)
+        str="%-15s: %-20s"
+        str_h1="%-80s"
+
+        CLIHelper.print_header(str_h1 % "IMAGE #{image['ID']} INFORMATION")
+        puts str % ["ID",   image.id.to_s]
+        puts str % ["NAME", image.name]
+        puts str % ["USER", image['UNAME']]
+        puts str % ["GROUP",image['GNAME']]
+        puts str % ["DATASTORE",image['DATASTORE']]
+        puts str % ["TYPE", image.type_str]
+        puts str % ["REGISTER TIME",
+            OpenNebulaHelper.time_to_str(image['REGTIME'])]
+        puts str % ["PERSISTENT",
+            OpenNebulaHelper.boolean_to_str(image["PERSISTENT"])]
+        puts str % ["SOURCE",image['SOURCE']]
+        puts str % ["PATH",image['PATH']] if image['PATH'] && !image['PATH'].empty?
+        puts str % ["FSTYPE",image['FSTYPE']] if image['FSTYPE'] && !image['FSTYPE'].empty?
+        puts str % ["SIZE",  OpenNebulaHelper.unit_to_str(image['SIZE'].to_i,{},"M")]
+        puts str % ["STATE", image.short_state_str]
+        puts str % ["RUNNING_VMS", image['RUNNING_VMS']]
+        puts
+
+        CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
+
+        ["OWNER", "GROUP", "OTHER"].each { |e|
+            mask = "---"
+            mask[0] = "u" if image["PERMISSIONS/#{e}_U"] == "1"
+            mask[1] = "m" if image["PERMISSIONS/#{e}_M"] == "1"
+            mask[2] = "a" if image["PERMISSIONS/#{e}_A"] == "1"
+
+            puts str % [e,  mask]
+        }
+        puts
+
+        CLIHelper.print_header(str_h1 % "IMAGE TEMPLATE",false)
+        puts image.template_str
+    end
+
+    def self.create_image_variables(options, name)
+        if Array===name
+            names=name
+        else
+            names=[name]
+        end
+
+        t=''
+        names.each do |n|
+            if options[n]
+                t<<"#{n.to_s.upcase}=\"#{options[n]}\"\n"
+            end
+        end
+
+        t
+    end
+
+    def self.create_image_template(options)
+        template_options=TEMPLATE_OPTIONS.map do |o|
+            o[:name].to_sym
+        end
+
+        template=create_image_variables(
+            options, template_options-[:persistent])
+
+        template<<"PERSISTENT=YES\n" if options[:persistent]
+
+        [0, template]
+    end
+end