#!/usr/bin/env ruby # -------------------------------------------------------------------------- # # Copyright 2002-2013, OpenNebula Project (OpenNebula.org), C12G Labs # # # # 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` [] []" version OpenNebulaHelper::ONE_VERSION helper = OneVMHelper.new before_proc do helper.set_client(options) end TYPE={ :name => "type", :short => "-t type", :large => "--type type", :format => String, :description => "Type of the new Image" } TARGET={ :name => "target", :short => "-t target", :large => "--target target", :format => String, :description => "Device where the image will be attached" } IP={ :name => "ip", :short => "-i ip", :large => "--ip ip", :format => String, :description => "IP address for the new NIC" } CACHE={ :name => "cache", :large => "--cache cache_mode", :format => String, :description => "Hypervisor cache mode: default, none, writethrough,"<< " writeback, directsync or unsafe. (Only KVM driver)" } ENFORCE={ :name => "enforce", :short => "-e", :large => "--enforce", :description => "Enforce that the host capacity is not exceeded" } SUCCESS={ :name => "success", :large => "--success", :description => "Recover a VM by succeeding the pending action" } FAILURE={ :name => "failure", :large => "--failure", :description => "Recover a VM by failing the pending action" } ######################################################################## # Global Options ######################################################################## set :option, CommandParser::OPTIONS+OpenNebulaHelper::CLIENT_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, :datastoreid, OpenNebulaHelper.rname_to_id_desc("DATASTORE") do |arg| OpenNebulaHelper.rname_to_id(arg, "DATASTORE") 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, OneVMHelper::HOLD]+ 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 if options[:dry] puts template exit 0 end on_hold = options[:hold] != nil number.times do exit_code = helper.create_resource(options) do |vm| error = vm.allocate(template, on_hold) end break if exit_code == -1 end exit_code end update_desc = <<-EOT.unindent Update the user template contents. If a path is not provided the editor will be launched to modify the current content. EOT command :update, update_desc, :vmid, [:file, nil], :options=>OpenNebulaHelper::APPEND do helper.perform_action(args[0],options,"modified") do |obj| if options[:append] str = OpenNebulaHelper.append_template(args[0], obj, args[1], 'USER_TEMPLATE') else str = OpenNebulaHelper.update_template(args[0], obj, args[1], 'USER_TEMPLATE') end obj.update(str, options[:append]) end end delete_desc = <<-EOT.unindent Deletes the given VM. Using --recreate resubmits the VM. 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 EOT command :delete, delete_desc, [:range, :vmid_list], :options => [OneVMHelper::SCHEDULE, OneVMHelper::RECREATE] do command_name="delete" command_name<<"-recreate" if options[:recreate] if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, command_name) else helper.perform_actions(args[0],options,"deleted") do |vm| vm.delete(options[:recreate]==true) end 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], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"put on hold") do |vm| vm.hold end end end release_desc = <<-EOT.unindent Releases a VM on hold. See 'onevm hold' States: HOLD EOT command :release, release_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"released") do |vm| vm.release end end end disk_snapshot_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') If '--live' is specified, the Image will be saved immediately. States: ANY EOT command :"disk-snapshot", disk_snapshot_desc, :vmid, :diskid, :img_name, :options=>[TYPE, OneVMHelper::LIVE] 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.disk_snapshot(disk_id, image_name, image_type, options[:live]==true) 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. With --hard it unplugs the VM. States: RUNNING, UNKNOWN (with --hard) EOT command :shutdown, shutdown_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE, OneVMHelper::HARD] do command_name='shutdown' command_name<<'-hard' if options[:hard] if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, command_name) else helper.perform_actions(args[0],options,"shutting down") do |vm| vm.shutdown(options[:hard]==true) end end end undeploy_desc = <<-EOT.unindent Shuts down the given VM. The VM is saved in the system Datastore. With --hard it unplugs the VM. States: RUNNING EOT command :undeploy, undeploy_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE, OneVMHelper::HARD] do command_name='undeploy' command_name<<'-hard' if options[:hard] if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, command_name) else helper.perform_actions(args[0],options,"shutting down") do |vm| vm.undeploy(options[:hard]==true) end 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 resume' command. States: RUNNING EOT command :poweroff, poweroff_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE, OneVMHelper::HARD] do command_name='poweroff' command_name<<'-hard' if options[:hard] if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"shutting down") do |vm| vm.poweroff(options[:hard]==true) end end end reboot_desc = <<-EOT.unindent Reboots the given VM, this is equivalent to execute the reboot command from the VM console. The VM will be ungracefully rebooted if --hard is used. States: RUNNING EOT command :reboot, reboot_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE, OneVMHelper::HARD] do command_name='reboot' command_name<<'-hard' if options[:hard] if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, command_name) else helper.perform_actions(args[0],options,"rebooting") do |vm| vm.reboot(options[:hard]) end 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, [:datastoreid,nil], :options=>[ENFORCE] do host_id = args[1] verbose = "deploying in host #{host_id}" enforce = options[:enforce].nil? ? false : options[:enforce] ds_id = args[2].nil? ? -1 : args[2] helper.perform_actions(args[0],options,verbose) do |vm| vm.deploy(host_id, enforce, ds_id) end end migrate_desc = <<-EOT.unindent Migrates the given running VM to another Host. If used with --live parameter the miration is done without downtime. States: RUNNING EOT command :migrate, migrate_desc, [:range,:vmid_list], :hostid, :options=>[ENFORCE, OneVMHelper::LIVE] do host_id = args[1] verbose = "migrating to #{host_id}" helper.perform_actions(args[0],options,verbose) do |vm| vm.migrate( host_id, options[:live]==true, options[:enforce]==true) end end boot_desc = <<-EOT.unindent Boots the given VM. States: UNKNOWN, BOOT EOT command :boot, boot_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"booting") do |vm| vm.boot end 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], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"stopping") do |vm| vm.stop end 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], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"suspending") do |vm| vm.suspend end end end resume_desc = <<-EOT.unindent Resumes the execution of the a saved VM States: STOPPED, SUSPENDED, UNDEPLOYED, POWEROFF EOT command :resume, resume_desc, [:range,:vmid_list], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"resuming") do |vm| vm.resume end end end recover_desc = <<-EOT.unindent Recovers a stuck VM that is waiting for a driver operation. The recovery may be done by failing or succeeding the pending operation. YOU NEED TO MANUALLY CHECK THE VM STATUS ON THE HOST, to decide if the operation was successful or not. Example: A VM is stuck in "migrate" because of a hardware failure. You need to check if the VM is running in the new host or not to recover the vm with --success or --failure, respectively. States: Any ACTIVE state. EOT command :recover, recover_desc, [:range,:vmid_list], :options => [SUCCESS, FAILURE] do if !options[:success].nil? result = true elsif !options[:failure].nil? result = false else STDERR.puts "Need to specify the result of the pending action." STDERR.puts "\t--success recover the VM by succeeding the missing action." STDERR.puts "\t--failure recover the VM by failing the missing action." exit -1 end helper.perform_actions(args[0], options, "recovering") do |vm| vm.recover(result) end end disk_attach_desc = <<-EOT.unindent Attaches a disk to a running VM. When using --file add only one DISK instance. States: RUNNING EOT command :"disk-attach", disk_attach_desc, :vmid, :options => [OneVMHelper::FILE, OneVMHelper::IMAGE, TARGET, CACHE] do if options[:file].nil? and options[:image].nil? STDERR.puts "Provide a template file or an image:" STDERR.puts "\t--file " STDERR.puts "\t--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 if options[:cache] template<<", CACHE = \"#{options[:cache]}\"" end template << " ]" end helper.perform_action(args[0],options,"Attach disk") do |vm| vm.disk_attach(template) end end disk_detach_desc = <<-EOT.unindent Detaches a disk from a running VM States: RUNNING EOT command :"disk-detach", disk_detach_desc, :vmid, :diskid do diskid = args[1].to_i helper.perform_action(args[0],options,"Detach disk") do |vm| vm.disk_detach(diskid) end end nic_attach_desc = <<-EOT.unindent Attaches a NIC to a running VM. When using --file add only one NIC instance. States: RUNNING EOT command :"nic-attach", nic_attach_desc, :vmid, :options => [OneVMHelper::FILE, OneVMHelper::NETWORK, IP] do if options[:file].nil? and options[:network].nil? STDERR.puts "Provide a template file or a network:" STDERR.puts "\t--file " STDERR.puts "\t--network " exit -1 end if options[:file] template = File.read(options[:file]) else network_id = options[:network] ip = options[:ip] if ip template = "NIC = [ NETWORK_ID = #{network_id}, IP = #{ip} ]" else template = "NIC = [ NETWORK_ID = #{network_id} ]" end end helper.perform_action(args[0],options,"Attach NIC") do |vm| vm.nic_attach(template) end end nic_detach_desc = <<-EOT.unindent Detaches a NIC from a running VM States: RUNNING EOT command :"nic-detach", nic_detach_desc, :vmid, :nicid do nicid = args[1].to_i helper.perform_action(args[0],options,"Detach NIC") do |vm| vm.nic_detach(nicid) 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 rename_desc = <<-EOT.unindent Renames the VM EOT command :rename, rename_desc, :vmid, :name do helper.perform_action(args[0],options,"renamed") do |o| o.rename(args[1]) end end # TODO: Write a more complete description: # what is a snapshot (system snapshot) # how to revert to a snapshot snapshot_create_desc = <<-EOT.unindent Creates a new VM snapshot EOT command :"snapshot-create", snapshot_create_desc, [:range,:vmid_list], [:name, nil], :options => [OneVMHelper::SCHEDULE] do if (!options[:schedule].nil?) helper.schedule_actions(args[0], options, @comm_name) else helper.perform_actions(args[0],options,"snapshot created") do |o| o.snapshot_create(args[1]) end end end # TODO: Write a more complete description: snapshot_revert_desc = <<-EOT.unindent Reverts a VM to a saved snapshot EOT command :"snapshot-revert", snapshot_revert_desc, :vmid, :snapshot_id do helper.perform_action(args[0],options,"snapshot reverted") do |o| o.snapshot_revert(args[1].to_i) end end # TODO: Write a more complete description: snapshot_delete_desc = <<-EOT.unindent Delets a snapshot of a VM EOT command :"snapshot-delete", snapshot_delete_desc, :vmid, :snapshot_id do helper.perform_action(args[0],options,"snapshot deleted") do |o| o.snapshot_delete(args[1].to_i) 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, OneVMHelper::ALL_TEMPLATE] 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 resize_desc = <<-EOT.unindent Resizes the capacity of a Virtual Machine (offline, the VM cannot be RUNNING) EOT command :resize, resize_desc, :vmid, :options => OpenNebulaHelper::CAPACITY_OPTIONS_VM + [ENFORCE, OneVMHelper::FILE] do if options[:file] template = File.read(options[:file]) else template = "" if !options[:cpu].nil? template << "CPU = #{options[:cpu]}\n" end if !options[:vcpu].nil? template << "VCPU = #{options[:vcpu]}\n" end if !options[:memory].nil? template << "MEMORY = #{options[:memory]}\n" end end enforce = options[:enforce] || false helper.perform_action(args[0], options, "Resizing VM") do |vm| vm.resize(template, enforce) end end # Deprecated commands deprecated_command(:attachdisk, 'disk-attach') deprecated_command(:detachdisk, 'disk-detach') deprecated_command(:saveas, 'disk-snapshot') deprecated_command(:livemigrate, 'migrate --live') deprecated_command(:cancel, 'shutdown --hard') deprecated_command(:reset, 'reboot --hard') deprecated_command(:restart, 'boot') deprecated_command(:resubmit, 'delete --recreate') end