opennebula-cli 3.8.0.beta1

data/bin/onevm

@@ -0,0 +1,532 @@
+#!/usr/bin/env ruby
+
+# -------------------------------------------------------------------------- #
+# 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.                                             #
+#--------------------------------------------------------------------------- #
+
+ONE_LOCATION=ENV["ONE_LOCATION"]
+
+if !ONE_LOCATION
+    RUBY_LIB_LOCATION="/usr/lib/one/ruby"
+else
+    RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby"
+end
+
+$: << RUBY_LIB_LOCATION
+$: << RUBY_LIB_LOCATION+"/cli"
+
+require 'command_parser'
+require 'one_helper/onevm_helper'
+
+cmd=CommandParser::CmdParser.new(ARGV) do
+    usage "`onevm` <command> [<args>] [<options>]"
+    version OpenNebulaHelper::ONE_VERSION
+
+    helper = OneVMHelper.new
+
+
+    TYPE={
+        :name => "type",
+        :short => "-t type",
+        :large => "--type type",
+        :format => String,
+        :description => "Type of the new Image"
+    }
+
+    TARGET={
+        :name => "target",
+        :short => "-t type",
+        :large => "--target type",
+        :format => String,
+        :description => "Device where the image will be attached"
+    }
+
+    ########################################################################
+    # Global Options
+    ########################################################################
+    set :option, CommandParser::OPTIONS
+
+    ########################################################################
+    # Formatters for arguments
+    ########################################################################
+    set :format, :hostid, OpenNebulaHelper.rname_to_id_desc("HOST") do |arg|
+        OpenNebulaHelper.rname_to_id(arg, "HOST")
+    end
+
+    set :format, :groupid, OpenNebulaHelper.rname_to_id_desc("GROUP") do |arg|
+        OpenNebulaHelper.rname_to_id(arg, "GROUP")
+    end
+
+    set :format, :userid, OpenNebulaHelper.rname_to_id_desc("USER") do |arg|
+        OpenNebulaHelper.rname_to_id(arg, "USER")
+    end
+
+    set :format, :vmid, OneVMHelper.to_id_desc do |arg|
+        helper.to_id(arg)
+    end
+
+    set :format, :vmid_list, OneVMHelper.list_to_id_desc do |arg|
+        helper.list_to_id(arg)
+    end
+
+    set :format, :filterflag, OneVMHelper.filterflag_to_i_desc do |arg|
+        helper.filterflag_to_i(arg)
+    end
+
+    set :format, :diskid, "Integer" do |arg|
+        format_int(arg)
+    end
+
+    ########################################################################
+    # Commands
+    ########################################################################
+
+    create_desc = <<-EOT.unindent
+        Creates a new VM from the given description instead of using a previously
+        defined template (see 'onetemplate create' and 'onetemplate instantiate').
+
+        Examples:
+
+          - using a template description file:
+
+            onevm create vm_description.tmpl
+
+          - new VM named "arch vm" with a disk and a nic
+
+            onevm create --name "arch vm" --memory 128 --cpu 1 --disk arch \\
+                         --network private_lan
+
+          - a vm with two disks
+
+            onevm create --name "test vm" --memory 128 --cpu 1 --disk arch,data
+
+    EOT
+
+    command :create, create_desc, [:file, nil], :options =>
+            [OneVMHelper::MULTIPLE]+OpenNebulaHelper::TEMPLATE_OPTIONS_VM do
+
+        number    = options[:multiple] || 1
+        exit_code = nil
+
+        if args[0] && OpenNebulaHelper.create_template_options_used?(options)
+            STDERR.puts "You can not use both template file and template"<<
+                " creation options."
+            next -1
+        end
+
+        begin
+            if args[0]
+                template=File.read(args[0])
+            else
+                res = OpenNebulaHelper.create_template(options)
+
+                if res.first != 0
+                    STDERR.puts res.last
+                    next -1
+                end
+
+                template = res.last
+            end
+        rescue Exception => e
+            STDERR.puts "Error reading template."
+            next -1
+        end
+
+        number.times do
+            exit_code = helper.create_resource(options) do |vm|
+                error = vm.allocate(template)
+            end
+
+            break if exit_code == -1
+        end
+
+        exit_code
+    end
+
+    delete_desc = <<-EOT.unindent
+        Deletes the given VM
+
+        States: ANY
+    EOT
+
+    command :delete, delete_desc, [:range, :vmid_list] do
+        helper.perform_actions(args[0],options,"deleted") do |vm|
+            vm.finalize
+        end
+    end
+
+    hold_desc = <<-EOT.unindent
+        Sets the given VM on hold. A VM on hold is not scheduled until it is
+        released. It can be, however, deployed manually; see 'onevm deploy'
+
+        States: PENDING
+    EOT
+
+    command :hold, hold_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"put on hold") do |vm|
+            vm.hold
+        end
+    end
+
+    release_desc = <<-EOT.unindent
+        Releases a VM on hold. See 'onevm hold'
+
+        States: HOLD
+    EOT
+
+    command :release, release_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"released") do |vm|
+            vm.release
+        end
+    end
+
+    saveas_desc = <<-EOT.unindent
+        Sets the specified VM disk to be saved in a new Image. The Image is
+        created immediately, but the contents are saved only if the VM is
+        shut down gracefully (i.e., using 'onevm shutdown' and not
+        'onevm delete')
+
+        States: ANY
+    EOT
+
+    command :saveas, saveas_desc, :vmid, :diskid, :img_name, :options=>[TYPE] do
+        disk_id    = args[1].to_i
+        image_name = args[2]
+        image_type = options[:type] || ""
+
+        verbose = "disk #{disk_id} prepared to be saved in " <<
+                  "the image #{image_name}"
+
+        helper.perform_action(args[0],options,verbose) do |vm|
+            res = vm.save_as(disk_id, image_name, image_type)
+
+            if !OpenNebula.is_error?(res)
+                puts "Image ID: #{res}"
+            end
+
+            res
+        end
+    end
+
+    shutdown_desc = <<-EOT.unindent
+        Shuts down the given VM. The VM life cycle will end.
+
+        States: RUNNING
+    EOT
+
+    command :shutdown, shutdown_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"shutting down") do |vm|
+            vm.shutdown
+        end
+    end
+
+    poweroff_desc = <<-EOT.unindent
+        Powers off the given VM. The VM will remain in the poweroff state, and
+        can be powered on with the 'onevm restart' command.
+
+        States: RUNNING
+    EOT
+
+    command :poweroff, poweroff_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"shutting down") do |vm|
+            vm.poweroff
+        end
+    end
+
+    reboot_desc = <<-EOT.unindent
+        Reboots the given VM, this is equivalent to execute the reboot command
+        from the VM console.
+
+        States: RUNNING
+    EOT
+
+    command :reboot, reboot_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"rebooting") do |vm|
+            vm.reboot
+        end
+    end
+
+    reset_desc = <<-EOT.unindent
+        Resets the given VM
+
+        States: RUNNING
+    EOT
+
+    command :reset, reset_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"resetting") do |vm|
+            vm.reset
+        end
+    end
+
+    deploy_desc = <<-EOT.unindent
+        Deploys the given VM in the specified Host. This command forces the
+        deployment, in a standard installation the Scheduler is in charge
+        of this decision
+
+        States: PENDING
+    EOT
+
+    command :deploy, deploy_desc, [:range,:vmid_list], :hostid do
+        host_id = args[1]
+        verbose = "deploying in host #{host_id}"
+
+        helper.perform_actions(args[0],options,verbose) do |vm|
+            vm.deploy(host_id)
+        end
+    end
+
+    livemigrate_desc = <<-EOT.unindent
+        Migrates the given running VM to another Host without downtime
+
+        States: RUNNING
+    EOT
+
+    command :livemigrate, livemigrate_desc, [:range,:vmid_list], :hostid do
+        host_id = args[1]
+        verbose = "live migrating to #{host_id}"
+
+        helper.perform_actions(args[0],options,verbose) do |vm|
+            vm.live_migrate(host_id)
+        end
+    end
+
+    migrate_desc = <<-EOT.unindent
+        Saves the given running VM and starts it again in the specified Host
+
+        States: RUNNING
+    EOT
+
+    command :migrate, migrate_desc, [:range,:vmid_list], :hostid do
+        host_id = args[1]
+        verbose = "migrating to #{host_id}"
+
+        helper.perform_actions(args[0],options,verbose) do |vm|
+            vm.migrate(host_id)
+        end
+    end
+
+    restart_desc = <<-EOT.unindent
+        Boots the given VM.
+
+        States: UNKNOWN, BOOT, POWEROFF
+    EOT
+
+    command :restart, restart_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"restarting") do |vm|
+            vm.restart
+        end
+    end
+
+    resubmit_desc = <<-EOT.unindent
+        Resubmits the VM to PENDING state. This is intended for VMs stuck in a
+        transient state. To re-deploy a fresh copy of the same VM, create a
+        Template and instantiate it, see 'onetemplate instantiate'
+
+        States: ANY, except SUSPENDED or DONE
+    EOT
+
+    command :resubmit, resubmit_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"resubmiting") do |vm|
+            vm.resubmit
+        end
+    end
+
+    cancel_desc = <<-EOT.unindent
+        Cancels the given VM. The process is checked by OpenNebula, so
+        if the process fails the VM remains in running state. If the action
+        succeeds the VMDIR in the remote machine is not deleted
+
+        States: RUNNING
+    EOT
+
+    command :cancel, cancel_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"canceling") do |vm|
+            vm.cancel
+        end
+    end
+
+    stop_desc = <<-EOT.unindent
+        Stops a running VM. The VM state is saved and transferred back to the
+        front-end along with the disk files
+
+        States: RUNNING
+    EOT
+
+    command :stop, stop_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"stopping") do |vm|
+            vm.stop
+        end
+    end
+
+    suspend_desc = <<-EOT.unindent
+        Saves a running VM. It is the same as 'onevm stop', but the files
+        are left in the remote machine to later restart the VM there
+        (i.e. the resources are not freed and there is no need to
+        re-schedule the VM).
+
+        States: RUNNING
+    EOT
+
+    command :suspend, suspend_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"suspending") do |vm|
+            vm.suspend
+        end
+    end
+
+    resume_desc = <<-EOT.unindent
+        Resumes the execution of the a saved VM
+
+        States: STOPPED, SUSPENDED
+    EOT
+
+    command :resume, resume_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"resuming") do |vm|
+            vm.resume
+        end
+    end
+
+    attachdisk_desc = <<-EOT.unindent
+        Attaches a disk to a running VM
+
+        States: RUNNING
+    EOT
+
+    command :attachdisk, attachdisk_desc, :vmid,
+            :options => [OneVMHelper::FILE, OneVMHelper::IMAGE, TARGET] do
+
+        if options[:file].nil? and options[:image].nil?
+            STDERR.puts "Provide a template file or an image:"
+            STDERR.puts "\t--file  <file>"
+            STDERR.puts "\t--image <image>"
+            exit -1
+        end
+
+        if options[:file]
+            template = File.read(options[:file])
+        else
+            image_id = options[:image]
+            target = options[:target]
+            if target
+                template =
+                    "DISK = [ IMAGE_ID = #{image_id}, TARGET = #{target} ]"
+            else
+                template =
+                    "DISK = [ IMAGE_ID = #{image_id}, DEV_PREFIX = sd ]"
+            end
+        end
+
+        helper.perform_action(args[0],options,"Attach disk") do |vm|
+            vm.attachdisk(template)
+        end
+    end
+
+    detachdisk_desc = <<-EOT.unindent
+        Detaches a disk from a running VM
+
+        States: RUNNING
+    EOT
+
+    command :detachdisk, detachdisk_desc, :vmid, :diskid do
+        diskid = args[1].to_i
+
+        helper.perform_action(args[0],options,"Detach disk") do |vm|
+            vm.detachdisk(diskid)
+        end
+    end
+
+    chgrp_desc = <<-EOT.unindent
+        Changes the VM group
+    EOT
+
+    command :chgrp, chgrp_desc,[:range, :vmid_list], :groupid do
+        helper.perform_actions(args[0],options,"Group changed") do |vm|
+            vm.chown(-1, args[1].to_i)
+        end
+    end
+
+    chown_desc = <<-EOT.unindent
+        Changes the VM owner and group
+    EOT
+
+    command :chown, chown_desc, [:range, :vmid_list], :userid,
+            [:groupid,nil] do
+        gid = args[2].nil? ? -1 : args[2].to_i
+        helper.perform_actions(args[0],options,"Owner/Group changed") do |vm|
+            vm.chown(args[1].to_i, gid)
+        end
+    end
+
+    chmod_desc = <<-EOT.unindent
+        Changes the VM permissions
+    EOT
+
+    command :chmod, chmod_desc, [:range, :vmid_list], :octet do
+        helper.perform_actions(args[0],options, "Permissions changed") do |vm|
+            vm.chmod_octet(args[1])
+        end
+    end
+
+    resched_desc = <<-EOT.unindent
+        Sets the rescheduling flag for the VM.
+
+        States: RUNNING
+    EOT
+
+    command :resched, resched_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"Setting resched flag") do |vm|
+            vm.resched
+        end
+    end
+
+    unresched_desc = <<-EOT.unindent
+        Clears the rescheduling flag for the VM.
+
+        States: RUNNING
+    EOT
+
+    command :unresched, unresched_desc, [:range,:vmid_list] do
+        helper.perform_actions(args[0],options,"Clearing resched flag") do |vm|
+            vm.unresched
+        end
+    end
+
+    list_desc = <<-EOT.unindent
+        Lists VMs in the pool
+    EOT
+
+    command :list, list_desc, [:filterflag, nil],
+            :options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS+
+            [OpenNebulaHelper::DESCRIBE] do
+        helper.list_pool(options, false, args[0])
+    end
+
+    show_desc = <<-EOT.unindent
+        Shows information for the given VM
+    EOT
+
+    command :show, show_desc, :vmid,
+            :options=>OpenNebulaHelper::XML do
+        helper.show_resource(args[0],options)
+    end
+
+    top_desc = <<-EOT.unindent
+        Lists Images continuously
+    EOT
+
+    command :top, top_desc, [:filterflag, nil],
+            :options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS do
+        helper.list_pool(options, true, args[0])
+    end
+end