oneimage

#!/usr/bin/env ruby

# -------------------------------------------------------------------------- #
# Copyright 2002-2025, 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

# %%RUBYGEMS_SETUP_BEGIN%%
require 'load_opennebula_paths'
# %%RUBYGEMS_SETUP_END%%

$LOAD_PATH << RUBY_LIB_LOCATION
$LOAD_PATH << RUBY_LIB_LOCATION + '/cli'

require 'tempfile'
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'
    }

    NO_IP = {
        :name => 'no_ip',
        :large => '--no_ip',
        :description => 'Do not keep NIC addresses (MAC, IP and IP6)'
    }

    NO_NIC = {
        :name => 'no_nic',
        :large => '--no_nic',
        :description => 'Do not keep network mappings'
    }

    INCREMENT = {
        :name => 'increment',
        :large => '--increment increment_id',
        :format => Integer,
        :description => 'Use the given increment ID to restore the backup.'\
            ' If not provided the last one will be used'
    }

    NAME = {
        :name => 'name',
        :large => '--name name',
        :format => String,
        :description => 'Name of the new image'
    }

    DISK_ID = {
        :name   => 'disk_id',
        :large  => '--disk-id disk_id',
        :format => Integer,
        :description => 'Restore only selected disk ID'
    }

    ########################################################################
    # Global Options
    ########################################################################
    set :option, CommandParser::OPTIONS + OpenNebulaHelper::CLIENT_OPTIONS

    list_options  = CLIHelper::OPTIONS
    list_options += OpenNebulaHelper::FORMAT
    list_options << OpenNebulaHelper::NUMERIC
    list_options << OpenNebulaHelper::DESCRIBE
    list_options << OneImageHelper::FILTERS

    CREATE_OPTIONS = [OneDatastoreHelper::DATASTORE,
                      OneImageHelper::IMAGE,
                      NAME]

    ########################################################################
    # 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|
        tmp = helper.to_id(arg)
        @current_image = tmp[1]
        tmp
    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

    set :format, :snapshot_id, 'Snapshot name or id' do |arg|
        helper.retrieve_snapshot_id(@current_image, arg)
    end

    set :format, :size, 'Image size in MiB' do |arg|
        OpenNebulaHelper.size_in_mb(arg)
    end

    ########################################################################
    # Commands
    ########################################################################

    create_desc = <<-EOT.unindent
        Creates a new Image
        Examples:
          - using a template description file:

            oneimage create -d default centOS.tmpl

            #{OpenNebulaHelper::TEMPLATE_INPUT}

          - 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 --format 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

        no_check_capacity = !options[:no_check_capacity].nil?

        conflicting_opts = []
        if (args[0] || !(stdin = OpenNebulaHelper.read_stdin).empty?) &&
            OneImageHelper.create_template_options_used?(options, conflicting_opts)

            STDERR.puts 'You cannot pass template on STDIN and use template creation options, ' <<
                        "conflicting options: #{conflicting_opts.join(', ')}."

            next -1
        end

        helper.create_resource(options) do |image|
            begin
                if args[0]
                    template = File.read(args[0])
                elsif !stdin.empty?
                    template = stdin
                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], no_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, 'cloning') 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],
            :options => [OpenNebulaHelper::FORCE] do
        force = (options[:force] == true)
        helper.perform_actions(args[0], options, 'deleting') do |image|
            image.delete(force)
        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(OpenNebulaHelper.to_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, 'deleting snapshot') 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, 'reverting image state') 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, 'flattening snapshot') do |o|
            o.snapshot_flatten(args[1].to_i)
        end
    end

    resize_desc = <<-EOT.unindent
        Resizes an image. The image must be in READY state and only
        upsizing is supported (the new size must be greater than the
        current size).

        The size can be specified with the following suffixes:
            - T: TiB
            - G: GiB
            - M: MiB
        Default unit is MiB.
    EOT

    command :resize, resize_desc, :imageid, :size do
        helper.perform_action(args[0], options, 'resizing image') do |o|
            o.resize(args[1].to_s)
        end
    end

    restore_desc = <<-EOT.unindent
        Restore a backup image. It will restore the associated VM template to the VM template pool and
        the disk images to the selected image datastore.
    EOT

    command :restore,
            restore_desc,
            :imageid,
            :options => [OneDatastoreHelper::DATASTORE, NO_NIC, NO_IP, NAME, INCREMENT, DISK_ID] do
        helper.perform_action(args[0], options, 'vm backup restored') do |o|
            if options[:datastore].nil?
                STDERR.puts 'Datastore to restore the backup is mandatory: '
                STDERR.puts "\t -d datastore_id | name"
                exit(-1)
            end

            restore_opts = ''

            restore_opts << "NO_NIC=\"YES\"\n" if options[:no_nic]
            restore_opts << "NO_IP=\"YES\"\n" if options[:no_ip]
            restore_opts << "NAME=\"#{options[:name]}\"\n" if options[:name]
            restore_opts << "INCREMENT_ID=\"#{options[:increment]}\"\n" if options[:increment]
            restore_opts << "DISK_ID=\"#{options[:disk_id]}\"\n" if options[:disk_id]

            rc = o.restore(options[:datastore].to_i, restore_opts)

            if !OpenNebula.is_error?(rc)
                ids = rc.split(' ')

                puts "VM Template: #{ids[0]}" if ids[0] && ids[0] != '-1'
                puts "Images: #{ids[1..-1].join(' ')}" if ids.length > 1
            else
                puts rc.message
                exit(-1)
            end
        end
    end

    list_desc = <<-EOT.unindent
        Lists Images in the pool. #{OneImageHelper.list_layout_help}
    EOT

    command :list, list_desc, [:filterflag, nil], :options => list_options do
        if options.key?(:backup)
            filter = 'TYPE=BK'

            if options[:filter]
                options[:filter] << filter
            else
                options[:filter] = [filter]
            end
            options.delete(:backup)
        end
        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::FORMAT, OpenNebulaHelper::DECRYPT] 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 an Image to prevent certain actions defined by different levels.
        The show action will never 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, [:range, :imageid_list],
            :options => [USE, MANAGE, ADMIN, ALL] do
        helper.perform_actions(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 an Image.
        Valid states are: All.
    EOT

    command :unlock, unlock_desc, [:range, :imageid_list] do
        helper.perform_actions(args[0], options, 'Image unlocked') do |i|
            i.unlock
        end
    end

    show_desc = <<-EOT.unindent
        Shows orphans images (i.e images not referenced in any template).
    EOT

    command :orphans, show_desc do
        puts helper.check_orphans

        return 0
    end
end