mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-23 05:04:56 +09:00
442 lines
13 KiB
Ruby
Executable File
442 lines
13 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
|
|
|
# -------------------------------------------------------------------------- #
|
|
# Copyright 2002-2019, OpenNebula Project, OpenNebula Systems #
|
|
# #
|
|
# 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'
|
|
GEMS_LOCATION = '/usr/share/one/gems'
|
|
else
|
|
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
|
|
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
|
|
end
|
|
|
|
if File.directory?(GEMS_LOCATION)
|
|
Gem.use_paths(GEMS_LOCATION)
|
|
end
|
|
|
|
$LOAD_PATH << RUBY_LIB_LOCATION
|
|
$LOAD_PATH << RUBY_LIB_LOCATION + '/cli'
|
|
|
|
require 'command_parser'
|
|
require 'one_helper/oneimage_helper'
|
|
require 'one_helper/onedatastore_helper'
|
|
|
|
CommandParser::CmdParser.new(ARGV) do
|
|
usage '`oneimage` <command> [<args>] [<options>]'
|
|
version OpenNebulaHelper::ONE_VERSION
|
|
|
|
helper = OneImageHelper.new
|
|
|
|
before_proc do
|
|
helper.set_client(options)
|
|
end
|
|
|
|
USE = {
|
|
:name => 'use',
|
|
:large => '--use',
|
|
:description => 'lock use actions'
|
|
}
|
|
|
|
MANAGE = {
|
|
:name => 'manage',
|
|
:large => '--manage',
|
|
:description => 'lock manage actions'
|
|
}
|
|
|
|
ADMIN = {
|
|
:name => 'admin',
|
|
:large => '--admin',
|
|
:description => 'lock admin actions'
|
|
}
|
|
|
|
ALL = {
|
|
:name => 'all',
|
|
:large => '--all',
|
|
:description => 'lock all actions'
|
|
}
|
|
|
|
########################################################################
|
|
# Global Options
|
|
########################################################################
|
|
set :option, CommandParser::OPTIONS + OpenNebulaHelper::CLIENT_OPTIONS
|
|
|
|
list_options = CLIHelper::OPTIONS
|
|
list_options << OpenNebulaHelper::XML
|
|
list_options << OpenNebulaHelper::NUMERIC
|
|
list_options << OpenNebulaHelper::DESCRIBE
|
|
|
|
CREATE_OPTIONS = [OneDatastoreHelper::DATASTORE, OneImageHelper::IMAGE]
|
|
|
|
########################################################################
|
|
# Formatters for arguments
|
|
########################################################################
|
|
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, :imageid, OneImageHelper.to_id_desc do |arg|
|
|
helper.to_id(arg)
|
|
end
|
|
|
|
set :format, :imageid_list, OneImageHelper.list_to_id_desc do |arg|
|
|
helper.list_to_id(arg)
|
|
end
|
|
|
|
set :format, :filterflag, OneImageHelper.filterflag_to_i_desc do |arg|
|
|
helper.filterflag_to_i(arg)
|
|
end
|
|
|
|
format(:type, "Image type: #{Image::IMAGE_TYPES.join(', ')}") do |arg|
|
|
type = arg.strip.upcase
|
|
if Image::IMAGE_TYPES.include? type
|
|
[0, type]
|
|
else
|
|
[1, 'Image type not supported. Must be ' <<
|
|
Image::IMAGE_TYPES.join(', ') << '.']
|
|
end
|
|
end
|
|
|
|
########################################################################
|
|
# Commands
|
|
########################################################################
|
|
|
|
create_desc = <<-EOT.unindent
|
|
Creates a new Image
|
|
Examples:
|
|
- using a template description file:
|
|
|
|
oneimage create -d default centOS.tmpl
|
|
|
|
- new image "arch" using a path:
|
|
|
|
oneimage create -d default --name arch --path /tmp/arch.img
|
|
|
|
- new persistent image, OS type and qcow2 format:
|
|
|
|
oneimage create -d 1 --name ubuntu --path /tmp/ubuntu.qcow2 \\
|
|
--prefix sd --type OS --driver qcow2 \\
|
|
--description "A OS plain installation \\
|
|
--persistent"
|
|
|
|
- a datablock image of 400MB:
|
|
|
|
oneimage create -d 1 --name data --type DATABLOCK --size 400
|
|
|
|
EOT
|
|
|
|
command :create,
|
|
create_desc,
|
|
[:file, nil],
|
|
:options => CREATE_OPTIONS + OneImageHelper::TEMPLATE_OPTIONS do
|
|
if options[:datastore].nil? && !options[:dry]
|
|
STDERR.puts 'Datastore to save the image is mandatory: '
|
|
STDERR.puts '\t -d datastore_id'
|
|
exit(-1)
|
|
end
|
|
|
|
if options[:no_check_capacity].nil?
|
|
check_capacity = false
|
|
else
|
|
check_capacity = true
|
|
end
|
|
|
|
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
|
|
|
|
helper.create_resource(options) do |image|
|
|
begin
|
|
if args[0]
|
|
template = File.read(args[0])
|
|
else
|
|
res = OneImageHelper.create_image_template(options)
|
|
|
|
if res.first != 0
|
|
STDERR.puts res.last
|
|
next -1
|
|
end
|
|
|
|
template = res.last
|
|
end
|
|
|
|
if options[:dry]
|
|
puts template
|
|
exit 0
|
|
end
|
|
|
|
image.allocate(template, options[:datastore], check_capacity)
|
|
rescue StandardError => e
|
|
STDERR.puts e.message
|
|
exit(-1)
|
|
end
|
|
end
|
|
end
|
|
|
|
clone_desc = <<-EOT.unindent
|
|
Creates a new Image from an existing one
|
|
EOT
|
|
|
|
command :clone, clone_desc, :imageid, :name,
|
|
:options => [OneDatastoreHelper::DATASTORE] do
|
|
helper.perform_action(args[0], options, 'cloned') do |image|
|
|
ds_id = options[:datastore] || -1 # -1 clones to self
|
|
res = image.clone(args[1], ds_id)
|
|
|
|
if !OpenNebula.is_error?(res)
|
|
puts "ID: #{res}"
|
|
else
|
|
puts res.message
|
|
exit(-1)
|
|
end
|
|
end
|
|
end
|
|
|
|
delete_desc = <<-EOT.unindent
|
|
Deletes the given Image
|
|
EOT
|
|
|
|
command :delete, delete_desc, [:range, :imageid_list] do
|
|
helper.perform_actions(args[0], options, 'deleted') do |image|
|
|
image.delete
|
|
end
|
|
end
|
|
|
|
persistent_desc = <<-EOT.unindent
|
|
Makes the given Image persistent. A persistent Image saves the changes
|
|
made to the contents after the VM instance is shutdown (or in real time
|
|
if a shared FS is used). Persistent Images can be used by only
|
|
one VM instance at a time.
|
|
EOT
|
|
|
|
command :persistent, persistent_desc, [:range, :imageid_list] do
|
|
helper.perform_actions(args[0], options, 'made persistent') do |image|
|
|
image.persistent
|
|
end
|
|
end
|
|
|
|
nonpersistent_desc = <<-EOT.unindent
|
|
Makes the given Image non persistent. See 'oneimage persistent'
|
|
EOT
|
|
|
|
command :nonpersistent, nonpersistent_desc, [:range, :imageid_list] do
|
|
helper.perform_actions(args[0],
|
|
options,
|
|
'made non persistent') do |image|
|
|
image.nonpersistent
|
|
end
|
|
end
|
|
|
|
update_desc = <<-EOT.unindent
|
|
Update the template contents. If a path is not provided the editor will
|
|
be launched to modify the current content.
|
|
EOT
|
|
|
|
command :update, update_desc, :imageid, [: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])
|
|
else
|
|
str = OpenNebulaHelper.update_template(args[0], obj, args[1])
|
|
end
|
|
|
|
helper.set_client(options)
|
|
obj = helper.retrieve_resource(obj.id)
|
|
|
|
obj.update(str, options[:append])
|
|
end
|
|
end
|
|
|
|
enable_desc = <<-EOT.unindent
|
|
Enables the given Image
|
|
EOT
|
|
|
|
command :enable, enable_desc, [:range, :imageid_list] do
|
|
helper.perform_actions(args[0], options, 'enabled') do |image|
|
|
image.enable
|
|
end
|
|
end
|
|
|
|
chtype_desc = <<-EOT.unindent
|
|
Changes the Image's type
|
|
EOT
|
|
|
|
command :chtype, chtype_desc, [:range, :imageid_list], :type do
|
|
helper.perform_actions(args[0], options, 'Type changed') do |image|
|
|
image.chtype(args[1])
|
|
end
|
|
end
|
|
|
|
disable_desc = <<-EOT.unindent
|
|
Disables the given Image
|
|
EOT
|
|
|
|
command :disable, disable_desc, [:range, :imageid_list] do
|
|
helper.perform_actions(args[0], options, 'disabled') do |image|
|
|
image.disable
|
|
end
|
|
end
|
|
|
|
chgrp_desc = <<-EOT.unindent
|
|
Changes the Image group
|
|
EOT
|
|
|
|
command :chgrp, chgrp_desc, [:range, :imageid_list], :groupid do
|
|
helper.perform_actions(args[0], options, 'Group changed') do |image|
|
|
image.chown(-1, args[1].to_i)
|
|
end
|
|
end
|
|
|
|
chown_desc = <<-EOT.unindent
|
|
Changes the Image owner and group
|
|
EOT
|
|
|
|
command :chown, chown_desc, [:range, :imageid_list], :userid,
|
|
[:groupid, nil] do
|
|
args[2].nil? ? gid = -1 : gid = args[2].to_i
|
|
helper.perform_actions(args[0], options,
|
|
'Owner/Group changed') do |image|
|
|
image.chown(args[1].to_i, gid)
|
|
end
|
|
end
|
|
|
|
chmod_desc = <<-EOT.unindent
|
|
Changes the Image permissions
|
|
EOT
|
|
|
|
command :chmod, chmod_desc, [:range, :imageid_list], :octet do
|
|
helper.perform_actions(args[0], options,
|
|
'Permissions changed') do |image|
|
|
image.chmod_octet(args[1])
|
|
end
|
|
end
|
|
|
|
rename_desc = <<-EOT.unindent
|
|
Renames the Image
|
|
EOT
|
|
|
|
command :rename, rename_desc, :imageid, :name do
|
|
helper.perform_action(args[0], options, 'renamed') do |o|
|
|
o.rename(args[1])
|
|
end
|
|
end
|
|
|
|
snapshot_delete_desc = <<-EOT.unindent
|
|
Deletes a snapshot from the image
|
|
EOT
|
|
|
|
command :'snapshot-delete', snapshot_delete_desc, :imageid, :snapshot_id do
|
|
helper.perform_action(args[0], options, 'snapshot deleted') do |o|
|
|
o.snapshot_delete(args[1].to_i)
|
|
end
|
|
end
|
|
|
|
snapshot_revert_desc = <<-EOT.unindent
|
|
Reverts image state to a snapshot
|
|
EOT
|
|
|
|
command :'snapshot-revert', snapshot_revert_desc, :imageid, :snapshot_id do
|
|
helper.perform_action(args[0], options, 'image state reverted') do |o|
|
|
o.snapshot_revert(args[1].to_i)
|
|
end
|
|
end
|
|
|
|
snapshot_flatten_desc = <<-EOT.unindent
|
|
Flattens the snapshot and removes all other snapshots in the image
|
|
EOT
|
|
|
|
command :'snapshot-flatten',
|
|
snapshot_flatten_desc,
|
|
:imageid,
|
|
:snapshot_id do
|
|
helper.perform_action(args[0], options, 'snapshot flattened') do |o|
|
|
o.snapshot_flatten(args[1].to_i)
|
|
end
|
|
end
|
|
|
|
list_desc = <<-EOT.unindent
|
|
Lists Images in the pool
|
|
EOT
|
|
|
|
command :list, list_desc, [:filterflag, nil], :options => list_options do
|
|
helper.list_pool(options, false, args[0])
|
|
end
|
|
|
|
show_desc = <<-EOT.unindent
|
|
Shows information for the given Image
|
|
EOT
|
|
|
|
command :show, show_desc, :imageid, :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 => list_options do
|
|
helper.list_pool(options, true, args[0])
|
|
end
|
|
|
|
lock_desc = <<-EOT.unindent
|
|
Locks a VM with differents levels for lock any actions with this VM, show and
|
|
monitoring never will be locked.
|
|
Valid states are: All.
|
|
Levels:
|
|
[Use]: locks Admin, Manage and Use actions.
|
|
[Manage]: locks Manage and Use actions.
|
|
[Admin]: locks only Admin actions.
|
|
EOT
|
|
|
|
command :lock, lock_desc, :imageid,
|
|
:options => [USE, MANAGE, ADMIN, ALL] do
|
|
helper.perform_action(args[0], options, 'Image locked') do |i|
|
|
if !options[:use].nil?
|
|
level = 1
|
|
elsif !options[:manage].nil?
|
|
level = 2
|
|
elsif !options[:admin].nil?
|
|
level = 3
|
|
elsif !options[:all].nil?
|
|
level = 4
|
|
else
|
|
level = 1
|
|
end
|
|
i.lock(level)
|
|
end
|
|
end
|
|
|
|
unlock_desc = <<-EOT.unindent
|
|
Unlocks a VM for unlock any actions with this VM.
|
|
Valid states are: All.
|
|
EOT
|
|
|
|
command :unlock, unlock_desc, :imageid do
|
|
helper.perform_action(args[0], options, 'Image unlocked') do |i|
|
|
i.unlock
|
|
end
|
|
end
|
|
end
|