mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-19 03:12:55 +09:00
350 lines
10 KiB
Ruby
Executable File
350 lines
10 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
|
|
# -------------------------------------------------------------------------- #
|
|
# Copyright 2002-2011, 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
|
|
|
|
########################################################################
|
|
# 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
|
|
|
|
########################################################################
|
|
# Commands
|
|
########################################################################
|
|
|
|
create_desc = <<-EOT.unindent
|
|
Creates a new VM from the given template file. This command bypasses
|
|
the Template pool, which is the preferred way to instantiate new VMs.
|
|
See 'onetemplate create' and 'onetemplate instantiate'
|
|
EOT
|
|
|
|
command :create, create_desc, :file,
|
|
:options=>[OneVMHelper::MULTIPLE]+OpenNebulaHelper::OPTIONS do
|
|
number = options[:multiple] || 1
|
|
|
|
exit_code=nil
|
|
|
|
number.times do
|
|
exit_code=helper.create_resource(options) do |vm|
|
|
template=File.read(args[0])
|
|
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 inmediately, but the contents are saved only if the VM is
|
|
shut down gracefuly (i.e., using 'onevm shutdown' and not
|
|
'onevm delete')
|
|
|
|
States: ANY
|
|
EOT
|
|
|
|
command :saveas, saveas_desc, :vmid, :diskid, :img_name do
|
|
disk_id = args[1].to_i
|
|
image_name = args[2]
|
|
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)
|
|
|
|
if !OpenNebula.is_error?(res)
|
|
puts "Image ID: #{res}"
|
|
end
|
|
|
|
res
|
|
end
|
|
end
|
|
|
|
shutdown_desc = <<-EOT.unindent
|
|
Shuts down the given VM.
|
|
|
|
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
|
|
|
|
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
|
|
Forces a re-deployment of the given VM, issuing a boot action.
|
|
|
|
States: UNKNOWN, BOOT
|
|
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 intented for VMs stuck in a
|
|
transient state. To re-deploy a fresh copy of the same VM, create a
|
|
Template and instantiante 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
|
|
|
|
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 Image 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
|
|
|
|
list_desc = <<-EOT.unindent
|
|
Lists VMs in the pool
|
|
EOT
|
|
|
|
command :list, list_desc, [:filterflag, nil],
|
|
:options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS 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
|