Files
one/src/cli/oneimage
T
2019-09-02 19:29:46 +02:00

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