OpenNebula

#!/usr/bin/env ruby

# ---------------------------------------------------------------------------- #

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

# ---------------------------------------------------------------------------- #

# clone fe:SOURCE host:remote_system_ds/disk.i vmid dsid

#   - fe is the front-end hostname

#   - SOURCE is the path of the disk image in the form DS_BASE_PATH/disk

#   - host is the target host to deploy the VM

#   - remote_system_ds is the path for the system datastore in the host

#   - vmid is the id of the VM

#   - dsid is the target datastore (0 is the system datastore)

ONE_LOCATION=ENV["ONE_LOCATION"] if !defined?(ONE_LOCATION)

if !ONE_LOCATION

    RUBY_LIB_LOCATION="/usr/lib/one/ruby" if !defined?(RUBY_LIB_LOCATION)

else

    RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby" if !defined?(RUBY_LIB_LOCATION)

end

$: << RUBY_LIB_LOCATION

$: << File.dirname(__FILE__)

require 'opennebula'

require 'vcenter_driver'

require 'digest'

################################################################################

def check_valid(parameter, label)

    if parameter.nil? || parameter.empty?

        STDERR.puts "Not enough information to clone the image. " +

                    "Missing '#{label}'."

        exit -1

    end

end

################################################################################

src          = ARGV[0]

dst          = ARGV[1]

vm_id        = ARGV[2]

source_ds_id = ARGV[3]

target_ds_id = dst.split("/")[-3]

disk_id = dst.split(".")[-1]

src_host, src_path = src.split ":"

hostname, dst_path = dst.split ":"

client = OpenNebula::Client.new

ds_pool = OpenNebula::DatastorePool.new(client)

rc = ds_pool.info

if OpenNebula.is_error?(rc)

     puts rc.message

     exit -1

end

xml = "/DATASTORE_POOL/DATASTORE[ID='#{source_ds_id}']/TEMPLATE/VCENTER_NAME"

source_ds = ds_pool[xml]

xml = "/DATASTORE_POOL/DATASTORE[ID='#{target_ds_id}']/TEMPLATE/VCENTER_NAME"

target_ds = ds_pool[xml]

################################################################################

# Generate target path

target_path = "one_#{vm_id}_#{disk_id}.vmdk"

################################################################################

# Check for errors

check_valid source_ds, "source_ds"

check_valid target_ds, "target_ds"

check_valid hostname, "hostname"

check_valid src_path, "src_path"

################################################################################

begin

    host_id   = VCenterDriver::VIClient.translate_hostname(hostname)

    vi_client = VCenterDriver::VIClient.new host_id

    vi_client.copy_virtual_disk(src_path, source_ds, target_path, target_ds)

rescue Exception => e

    STDERR.puts "Error cloning img #{src_path} size. Reason: #{e.message}"

    exit -1

end

# Return if this has called for the whole directory, instead of for a specific

# disk.

if !ARGV[0].match(/disk\.\d+$/)

    exit(0)

end

# ---------------------------------------------------------------------------- #

require 'opennebula'

client = OpenNebula::Client.new

vm = OpenNebula::VirtualMachine.new_with_id(vmid, client)

vm.info

disk_id = img_path.split(".")[-1]

persistent = vm["TEMPLATE/DISK[DISK_ID=#{disk_id}]/PERSISTENT"]

if persistent != "YES"

    img_path = "one_#{vmid}_#{disk_id}.vmdk"

end

                " Reason: #{e.message}\n#{e.backtrace}"

        ds = OpenNebula::Datastore.new_with_id(ds_id, OpenNebula::Client.new)

                vm = connection.find_vm_template(deploy_id)

        vm   = connection.find_vm_template(deploy_id)

        vmid = get_vm_id

                ds_name    = disk.elements["DATASTORE"].text

                img_name   = get_disk_img_path(disk, vmid)

                type_str   = disk.elements["TYPE"].text

                disk_array += attach_disk("", "", ds_name, img_name, type_str, 0, vm, connection)[:deviceChange]

        ds = datastores.select{|ds| ds.name == ds_name}[0]

        vmid =  vm.config.extraConfig.select do |val|

                    val[:key] == "opennebula.vm.id"

                end.first.value

            img_name = get_disk_img_path(disk, vmid)

            ds_and_img_name = "[#{disk['DATASTORE']}] #{img_name}"

            vcenter_disk = vm.config.hardware.device.select { |d| is_disk?(d) &&

            spec[:deviceChange] <<  {

    ############################################################################

    # Returns the source path of a disk. It will use the 'SOURCE' path if

    # persistent and one-#{vm_id}-#{disk_id}.vmdk otherwise

    # @param disks VM attached disks, either an REXML document, or a hash

    # @param vmid The VM ID

    ############################################################################

    def self.get_disk_img_path(disk, vmid)

        if disk.respond_to? :elements

            # It's a REXML::Document, probably coming from self.reconfigure_vm

            persistent = disk.elements["PERSISTENT"].text == "YES" rescue false

            if persistent

                disk.elements["SOURCE"].text

            else

                disk_id = disk.elements["DISK_ID"].text

                "one_#{vmid}_#{disk_id}.vmdk"

            end

        else

            # It's a hash, probably coming from self.detach_attached_disks

            persistent = disk["PERSISTENT"] == "YES"

            if persistent

                disk["SOURCE"]

            else

                disk_id = disk["DISK_ID"]

                "one_#{vmid}_#{disk_id}.vmdk"

            end

        end

    end