opennebula-cli 3.8.0.beta1

data/lib/one_helper/onequota_helper.rb

@@ -0,0 +1,256 @@
+# -------------------------------------------------------------------------- #
+# 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'
+
+class OneQuotaHelper
+
+    EDITOR_PATH='/usr/bin/vi'
+
+    #---------------------------------------------------------------------------
+    #  Tables to format user quotas
+    #---------------------------------------------------------------------------
+    TABLE_DS = CLIHelper::ShowTable.new(nil, self) do
+        column :"DATASTORE ID", "", :size=>12 do |d|
+            d["ID"] if !d.nil?
+        end
+
+        column :"IMAGES", "", :right, :size=>20 do |d|
+            "%8d / %8d" % [d["IMAGES_USED"], d["IMAGES"]] if !d.nil?
+        end
+
+        column :"SIZE", "", :right, :size=>19 do |d|
+            "%8s / %8s" % [OpenNebulaHelper.unit_to_str(d["SIZE_USED"].to_i,{},"M"),
+                OpenNebulaHelper.unit_to_str(d["SIZE"].to_i,{},"M")] if !d.nil?
+        end
+    end
+
+    TABLE_NET = CLIHelper::ShowTable.new(nil, self) do
+        column :"NETWORK ID", "", :size=>12 do |d|
+            d["ID"] if !d.nil?
+        end
+
+        column :"LEASES", "", :right, :size=>20 do |d|
+            "%8d / %8d" % [d["LEASES_USED"], d["LEASES"]] if !d.nil?
+        end
+    end
+
+    TABLE_VM = CLIHelper::ShowTable.new(nil, self) do
+
+        column :"NUMBER OF VMS", "", :right, :size=>20 do |d|
+            "%8d / %8d" % [d["VMS_USED"], d["VMS"]] if !d.nil?
+        end
+
+        column :"MEMORY", "", :right, :size=>20 do |d|
+            "%8s / %8s" % [OpenNebulaHelper.unit_to_str(d["MEMORY_USED"].to_i,{},"M"),
+                OpenNebulaHelper.unit_to_str(d["MEMORY"].to_i,{},"M")] if !d.nil?
+        end
+
+        column :"CPU", "", :right, :size=>20 do |d|
+            "%8.2f / %8.2f" % [d["CPU_USED"], d["CPU"]] if !d.nil?
+        end
+    end
+
+    TABLE_IMG = CLIHelper::ShowTable.new(nil, self) do
+        column :"IMAGE ID", "", :size=>12 do |d|
+            d["ID"] if !d.nil?
+        end
+
+        column :"RUNNING VMS", "", :right, :size=>20 do |d|
+            "%8d / %8d" % [d["RVMS_USED"], d["RVMS"]] if !d.nil?
+        end
+    end
+
+    HELP_QUOTA = <<-EOT.unindent
+        #-----------------------------------------------------------------------
+        # Supported quota limits:
+        #
+        #  DATASTORE = [
+        #    ID     = <ID of the datastore>
+        #    IMAGES = <Max. number of images in the datastore>
+        #    SIZE   = <Max. storage capacity (Mb) used in the datastore>
+        #  ]
+        #
+        #  VM = [
+        #    VMS    = <Max. number of VMs>
+        #    MEMORY = <Max. allocated memory (Mb)>
+        #    CPU    = <Max. allocated CPU>
+        #  ]
+        #
+        #  NETWORK = [
+        #    ID     = <ID of the network>
+        #    LEASES = <Max. number of IP leases from the network>
+        #  ]
+        #
+        #  IMAGE = [
+        #    ID        = <ID of the image>
+        #    RVMS = <Max. number of VMs using the image>
+        #  ]
+        #
+        #  In any quota 0 means unlimited. The usage counters "*_USED" are
+        #  shown for information purposes and will NOT be modified.
+        #-----------------------------------------------------------------------
+    EOT
+
+    #  Edits the quota template of a resource
+    #  @param resource [PoolElement] to get the current info from
+    #  @param path [String] path to the new contents. If nil a editor will be 
+    #         used
+    #  @return [String] contents of the new quotas
+    def self.set_quota(resource, path)
+        str = ""
+
+        if path.nil?
+            require 'tempfile'
+
+            tmp  = Tempfile.new('one-cli')
+            path = tmp.path
+
+            rc = resource.info
+
+            if OpenNebula.is_error?(rc)
+                puts rc.message
+                exit -1
+            end
+
+            tmp << HELP_QUOTA
+            tmp << resource.template_like_str("DATASTORE_QUOTA") << "\n"
+            tmp << resource.template_like_str("VM_QUOTA") << "\n"
+            tmp << resource.template_like_str("NETWORK_QUOTA") << "\n"
+            tmp << resource.template_like_str("IMAGE_QUOTA") << "\n"
+
+            tmp.close
+
+            editor_path = ENV["EDITOR"] ? ENV["EDITOR"] : EDITOR_PATH
+            system("#{editor_path} #{path}")
+
+            unless $?.exitstatus == 0
+                puts "Editor not defined"
+                exit -1
+            end
+
+            str = File.read(path)
+
+            File.unlink(path)
+        else
+            str = File.read(path)
+        end
+
+        str
+    end
+
+    #  Retrieves a clean quota template, without any existing resource
+    #  information
+    #  @param path [String] path to the new contents. If nil a editor will be 
+    #         used
+    #  @return [String] contents of the new quotas
+    def self.get_batch_quota(path)
+        str = ""
+
+        if path.nil?
+            require 'tempfile'
+
+            tmp  = Tempfile.new('one-cli')
+            path = tmp.path
+
+            tmp << HELP_QUOTA << "\n"
+
+            tmp.close
+
+            editor_path = ENV["EDITOR"] ? ENV["EDITOR"] : EDITOR_PATH
+            system("#{editor_path} #{path}")
+
+            unless $?.exitstatus == 0
+                puts "Editor not defined"
+                exit -1
+            end
+
+            str = File.read(path)
+
+            File.unlink(path)
+        else
+            str = File.read(path)
+        end
+
+        str
+    end
+
+    #  Edits the quota template of a resource, adding the quotas set in str
+    #  @param resource [PoolElement] to get the current info from
+    #  @param str [String] quota template, created by get_batch_quota()
+    #  @return [String, OpenNebula::Error] merged contents of the new quotas on 
+    #    success, Error if the user info could not be retrieved
+    def self.merge_quota(resource, str)
+        rc = resource.info
+
+        if OpenNebula.is_error?(rc)
+            return rc
+        end
+
+        # Instead of parsing the existing quotas, and deleting the ones that
+        # conflict with the batch quota string, the new quotas are placed at
+        # the end of the template sent to opennebula. This relies on the core
+        # reading them in order and replacing the quotas with each new
+        # appearance
+
+        tmp_str = ""
+
+        tmp_str << resource.template_like_str("DATASTORE_QUOTA") << "\n"
+        tmp_str << resource.template_like_str("VM_QUOTA") << "\n"
+        tmp_str << resource.template_like_str("NETWORK_QUOTA") << "\n"
+        tmp_str << resource.template_like_str("IMAGE_QUOTA") << "\n"
+
+        tmp_str << str
+
+        return tmp_str
+    end
+
+    #  Outputs formated quota information to stdout
+    #  @param qh [Hash] with the quotas for a given resource
+    #
+    def self.format_quota(qh)
+        str_h1="%-80s"
+
+        puts
+
+        CLIHelper.print_header(str_h1 % "RESOURCE USAGE & QUOTAS",false)
+
+        puts
+
+        vm_quotas = [qh['VM_QUOTA']['VM']].flatten
+        if !vm_quotas[0].nil?
+            TABLE_VM.show(vm_quotas, {})
+            puts
+        end
+
+        ds_quotas = [qh['DATASTORE_QUOTA']['DATASTORE']].flatten
+        if !ds_quotas[0].nil?
+            TABLE_DS.show(ds_quotas, {})
+            puts
+        end
+
+        net_quotas = [qh['NETWORK_QUOTA']['NETWORK']].flatten
+        if !net_quotas[0].nil?
+            TABLE_NET.show(net_quotas, {})
+            puts
+        end
+
+        image_quotas = [qh['IMAGE_QUOTA']['IMAGE']].flatten
+        if !image_quotas[0].nil?
+            TABLE_IMG.show(image_quotas, {})
+        end
+    end
+end

data/lib/one_helper/onetemplate_helper.rb

@@ -0,0 +1,123 @@
+# -------------------------------------------------------------------------- #
+# 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 OneTemplateHelper < OpenNebulaHelper::OneHelper
+    VM_NAME={
+        :name  => "name",
+        :large => "--name name",
+        :format => String,
+        :description =>  <<-EOT.strip
+Name of the new VM or TEMPLATE. When instantiating
+                               multiple VMs you can use the\"%i\" wildcard to produce
+                               different names such as vm-0, vm-1...
+EOT
+    }
+
+    MULTIPLE={
+        :name  => "multiple",
+        :short => "-m x",
+        :large => "--multiple x",
+        :format => Integer,
+        :description => "Instance multiple VMs"
+    }
+
+    def self.rname
+        "VMTEMPLATE"
+    end
+
+    def self.conf_file
+        "onetemplate.yaml"
+    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 Template", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the Template", :left, :size=>27 do |d|
+                d["NAME"]
+            end
+
+            column :USER, "Username of the Template owner", :left,
+                    :size=>15 do |d|
+                helper.user_name(d, options)
+            end
+
+            column :GROUP, "Group of the Template", :left, :size=>15 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :REGTIME, "Registration time of the Template",
+                    :size=>15 do |d|
+                OpenNebulaHelper.time_to_str(d["REGTIME"])
+            end
+
+            default :ID, :USER, :GROUP, :NAME, :REGTIME
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::Template.new_with_id(id, @client)
+        else
+            xml=OpenNebula::Template.build_xml
+            OpenNebula::Template.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        OpenNebula::TemplatePool.new(@client, user_flag)
+    end
+
+    def format_resource(template)
+        str="%-15s: %-20s"
+        str_h1="%-80s"
+
+        CLIHelper.print_header(
+            str_h1 % "TEMPLATE #{template['ID']} INFORMATION")
+        puts str % ["ID", template.id.to_s]
+        puts str % ["NAME", template.name]
+        puts str % ["USER", template['UNAME']]
+        puts str % ["GROUP", template['GNAME']]
+        puts str % ["REGISTER TIME",
+            OpenNebulaHelper.time_to_str(template['REGTIME'])]
+        puts
+
+        CLIHelper.print_header(str_h1 % "PERMISSIONS",false)
+
+        ["OWNER", "GROUP", "OTHER"].each { |e|
+            mask = "---"
+            mask[0] = "u" if template["PERMISSIONS/#{e}_U"] == "1"
+            mask[1] = "m" if template["PERMISSIONS/#{e}_M"] == "1"
+            mask[2] = "a" if template["PERMISSIONS/#{e}_A"] == "1"
+
+            puts str % [e,  mask]
+        }
+        puts
+
+        CLIHelper.print_header(str_h1 % "TEMPLATE CONTENTS",false)
+        puts template.template_str
+    end
+end

data/lib/one_helper/oneuser_helper.rb

@@ -0,0 +1,242 @@
+# -------------------------------------------------------------------------- #
+# 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 OneUserHelper < OpenNebulaHelper::OneHelper
+    def self.rname
+        "USER"
+    end
+
+    def self.conf_file
+        "oneuser.yaml"
+    end
+
+    def self.password_to_str_desc
+        "User password"
+    end
+
+    def self.password_to_str(arg, options)
+        if options[:read_file]
+            begin
+                password = File.read(arg).split("\n").first
+            rescue
+                return -1, "Cannot read file: #{arg}"
+            end
+        else
+            password = arg.dup
+        end
+
+        if options[:driver] == OpenNebula::User::X509_AUTH
+            password.delete!("\s")
+        end
+
+        if options[:sha1] || options[:driver] == OpenNebula::User::CIPHER_AUTH
+            require 'digest/sha1'
+            password = Digest::SHA1.hexdigest(password)
+        end
+
+        return 0, password
+    end
+
+    def password(options)
+        case options[:driver]
+        when OpenNebula::User::SSH_AUTH
+            if !options[:key]
+                return -1, "You have to specify the --key option"
+            end
+
+            require 'ssh_auth'
+
+            begin
+                auth = SshAuth.new(:private_key=>options[:key])
+            rescue Exception => e
+                return -1, e.message
+            end
+        when OpenNebula::User::X509_AUTH
+            options[:cert] ||= ENV['X509_USER_CERT']
+
+            if !options[:cert]
+                return -1, "You have to specify the --cert option"
+            end
+
+            require 'x509_auth'
+
+            begin
+                cert = [File.read(options[:cert])]
+                auth = X509Auth.new(:certs_pem=>cert)
+            rescue Exception => e
+                return -1, e.message
+            end
+        else
+            return -1, "You have to specify an Auth method or define a password"
+        end
+
+        return 0, auth.password
+    end
+
+    def self.login(username, options)
+        case options[:driver]
+        when OpenNebula::User::SSH_AUTH
+            require 'ssh_auth'
+
+            options[:key]  ||= ENV['HOME']+'/.ssh/id_rsa'
+
+            begin
+                auth = SshAuth.new(:private_key=>options[:key])
+            rescue Exception => e
+                return -1, e.message
+            end
+        when OpenNebula::User::X509_AUTH
+            require 'x509_auth'
+
+            options[:cert] ||= ENV['X509_USER_CERT']
+            options[:key]  ||= ENV['X509_USER_KEY']
+
+            begin
+                certs = [File.read(options[:cert])]
+                key   = File.read(options[:key])
+
+                auth = X509Auth.new(:certs_pem=>certs, :key_pem=>key)
+            rescue Exception => e
+                return -1, e.message
+            end
+        when OpenNebula::User::X509_PROXY_AUTH
+            require 'x509_auth'
+
+            options[:proxy] ||= ENV['X509_PROXY_CERT']
+
+            begin
+                proxy = File.read(options[:proxy])
+
+                certs = proxy.scan(/(-+BEGIN CERTIFICATE-+\n[^-]*\n-+END CERTIFICATE-+)/)
+                certs.flatten!
+
+                rc = proxy.match(/(-+BEGIN RSA PRIVATE KEY-+\n[^-]*\n-+END RSA PRIVATE KEY-+)/)
+                key= rc[1]
+
+                auth = X509Auth.new(:certs_pem=>certs, :key_pem=>key)
+            rescue => e
+                return -1, e.message
+            end
+        else
+            return -1, "You have to specify an Auth method"
+        end
+
+        options[:time] ||= 3600
+
+        auth.login(username, Time.now+options[:time])
+
+        return 0, 'export ONE_AUTH=' << auth.class::LOGIN_PATH
+    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 User", :size=>4 do |d|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the User", :left, :size=>15 do |d|
+                d["NAME"]
+            end
+
+            column :GROUP, "Group of the User", :left, :size=>10 do |d|
+                helper.group_name(d, options)
+            end
+
+            column :AUTH, "Auth driver of the User", :left, :size=>8 do |d|
+                d["AUTH_DRIVER"]
+            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')
+                    d['VM_QUOTA']['VM']['MEMORY_USED']
+                    "%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
+
+            column :PASSWORD, "Password of the User", :size=>50 do |d|
+                d['PASSWORD']
+            end
+
+            default :ID, :NAME, :GROUP, :AUTH, :VMS, :MEMORY, :CPU
+        end
+
+        table
+    end
+
+    private
+
+    def factory(id=nil)
+        if id
+            OpenNebula::User.new_with_id(id, @client)
+        else
+            xml=OpenNebula::User.build_xml
+            OpenNebula::User.new(xml, @client)
+        end
+    end
+
+    def factory_pool(user_flag=-2)
+        #TBD OpenNebula::UserPool.new(@client, user_flag)
+        OpenNebula::UserPool.new(@client)
+    end
+
+    def format_resource(user)
+        str="%-15s: %-20s"
+        str_h1="%-80s"
+
+        CLIHelper.print_header(str_h1 % "USER #{user['ID']} INFORMATION")
+        puts str % ["ID",          user.id.to_s]
+        puts str % ["NAME",        user.name]
+        puts str % ["GROUP",       user['GNAME']]
+        puts str % ["PASSWORD",    user['PASSWORD']]
+        puts str % ["AUTH_DRIVER", user['AUTH_DRIVER']]
+
+        puts str % ["ENABLED",
+            OpenNebulaHelper.boolean_to_str(user['ENABLED'])]
+
+        puts
+
+        CLIHelper.print_header(str_h1 % "USER TEMPLATE",false)
+        puts user.template_str
+
+        user_hash = user.to_hash
+
+        OneQuotaHelper.format_quota(user_hash['USER'])
+    end
+end