OpenNebula

    # VM XMLElement

    # OpenNebula host

    # Target Datastore VMware reference (must be defined when VM is new)

    attr_accessor :target_ds_ref

    # Cached vi_client

    # @return VIClient instance

    def vi_client

        if !@vi_client

            @item._connection

        end

        @vi_client

    end

    # vi_client setter (must be used when the VM does not exist in vCenter)

    def vi_client=(vi_client)

        @vi_client = vi_client

    end

    # Cached one_item

    def one_item

        # TODO: fetch one_item if it doesn't exist

        @one_item

    end

    # one_item setter (must be used when the VM does not exist in vCenter)

    def one_item=(one_item)

        @one_item = one_item

    end

    # Cached cluster

            ccr_ref = @host['TEMPLATE/VCENTER_CCR_REF']

            @cluster = ClusterComputeResource.new_from_ref(vi_client, ccr_ref)

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

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

    # @return Boolean whether the VM exists in vCenter

    def is_new?

        vm_id = self['config.extraConfig'].select do |o|

            o.key == "opennebula.vm.id"

        end.first.value rescue nil

        !vm_id

    end

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

    # Getters

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

        if vi_client.rp_confined?

            if req_rp && req_rp != vi_client.rp

                raise "Available resource pool in host [#{vi_client.rp}]"\

            return vi_client.rp

                return cluster['resourcePool']

            custom_spec = vi_client.vim

    # @return String image name

    def get_img_name(disk)

        if disk["PERSISTENT"] == "YES"

            return disk["SOURCE"]

        else

            image_id = disk["IMAGE_ID"]

            disk_id  = disk["DISK_ID"]

            vm_id    = one_item['ID']

            return "one-#{image_id}-#{vm_id}-#{disk_id}.vmdk"

        end

    end

    # @return VCenterDriver::Datastore datastore where the disk will live under

    def get_effective_ds(disk)

        if disk["PERSISTENT"] == "YES"

            ds_ref = disk["VCENTER_DS_REF"]

        else

            ds_ref = @target_ds_ref

            if ds_ref.nil?

                raise "target_ds_ref must be defined on this object."

            end

        VCenterDriver::Datastore.new_from_ref(vi_client, ds_ref)

    end

    # @return String vcenter name

    def get_vcenter_name

        vm_prefix = @host['TEMPLATE/VM_PREFIX']

        vm_prefix = VM_PREFIX_DEFAULT if vm_prefix.nil? || vm_prefix.empty?

        vm_prefix.gsub!("$i", one_item['ID'])

        vm_prefix + one_item['NAME']

    end

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

    # Crate and reconfigure VM related methods

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

    # When creating a new these instance variables must be set beforehand

    # @vi_client

    # @one_item

    # @host

    #

    # This function creates a new VM from the @one_item XML and returns the

    # VMware ref

    def clone_vm

        vcenter_name = get_vcenter_name

        vc_template_ref = one_item['USER_TEMPLATE/VCENTER_TEMPLATE_REF']

        vc_template = RbVmomi::VIM::VirtualMachine(vi_client.vim, vc_template_ref)

        clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(spec_hash_clone)

        vm = nil

        @item = vm

    # @return clone parameters spec hash

    def spec_hash_clone

        # Relocate spec

        relocate_spec_params = {}

        relocate_spec_params[:pool] = get_rp

        ds = get_ds

        if ds

            relocate_spec_params[:datastore] = ds

            relocate_spec_params[:diskMoveType] = :moveChildMostDiskBacking

        end

        # TODO storpod (L2575 vcenter_driver.rb)

        relocate_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(

                                                         relocate_spec_params)

        # Running flag - prevents spurious poweroff states in the VM

        running_flag = [{ :key => "opennebula.vm.running", :value => "no"}]

        running_flag_spec = RbVmomi::VIM.VirtualMachineConfigSpec(

            { :extraConfig => running_flag }

        )

        clone_parameters = {

            :location => relocate_spec,

            :powerOn  => false,

            :template => false,

            :config   => running_flag_spec

        }

        cs = get_customization

        clone_parameters[:customization] = cs if cs

        clone_parameters

    end

        extraconfig   = []

        device_change = []

        extraconfig += extraconfig_vmid

        extraconfig += extraconfig_context

        extraconfig += extraconfig_vnc

        device_change += device_change_nics

        device_change += device_change_disks

        num_cpus = one_item["TEMPLATE/VCPU"] || 1

        spec_hash = {

            :numCPUs      => num_cpus.to_i,

            :memoryMB     => one_item["TEMPLATE/MEMORY"],

            :extraConfig  => extraconfig

        }

        spec_hash[:deviceChange] = device_change if !device_change.empty?

        spec = RbVmomi::VIM.VirtualMachineConfigSpec(spec_hash)

        self.item.ReconfigVM_Task(:spec => spec).wait_for_completion

    def extraconfig_vmid

        [

            { :key => "opennebula.vm.id", :value => one_item['ID'] }

        ]

    def extraconfig_context

    def extraconfig_vnc

    def device_change_nics

        # Final list of changes to be applied in vCenter

        device_change = []

        # List of interfaces from the OpenNebula template

        # Remove detached nics in poweroff

            # To be included in device_change

            detach_nic_array = []

            nics.each do |nic|

                one_mac_addresses << nic["MAC"]

            end rescue nil

            # B4897 - Get mac of NICs that were hot-plugged from vCenter

            #  extraConfig

            # Get opennebula.hotplugged_nics attribute from the vCenter object

            extraconfig_nics = self["config.extraConfig"].select do |val|

            self["config.hardware.device"].each do |dv|

                    # nics array will contain the list of nics to be attached

                    nics.each do |nic|

                        if nic["MAC"] == dv.macAddress

                            nics.delete(nic)

                        end

                    end

                    # if the nic is in the list opennebula.hotplugged_nics and

                    #  not in the list of the OpenNebula NICs we can remove it.

                    # B4897 - Remove detached NICs from vCenter that were unplugged

                    #  in POWEROFF

                    if !one_mac_addresses.include?(dv.macAddress) &&

                        hotplugged_nics.include?(dv.macAddress)

                        detach_nic_array << {

                            :operation => :remove,

                            :device    => dv

                        }

                        hotplugged_nics.delete(dv.macAddress)

                        config_array << {

                            :key    => 'opennebula.hotplugged_nics',

                            :value  => hotplugged_nics.join(";")

                        }

                    end

                end

            end

            device_change += detach_nic_array

        end

        return if nics.empty?

        # Attach new nics (nics now contains only the interfaces not present

        # in the VM in vCenter)

        attach_nic_array = []

        nics.each do |nic|

            attach_nic_array << calculate_add_nic_spec(nic)

        end

        attach_nic_array

    end

    # Returns an array of actions to be included in :deviceChange

    def calculate_add_nic_spec(nic)

        mac     = nic["MAC"]

        bridge  = nic["BRIDGE"]

        model   = nic["MODEL"]

        backing = nil

        limit_in  = nic["INBOUND_PEAK_BW"]

        limit_out = nic["OUTBOUND_PEAK_BW"]

        limit     = nil

        if limit_in && limit_out

            limit=([limit_in.to_i, limit_out.to_i].min / 1024) * 8

        end

        rsrv_in  = nic["INBOUND_AVG_BW"]

        rsrv_out = nic["OUTBOUND_AVG_BW"]

        rsrv     = nil

        if rsrv_in || rsrv_out

            rsrv=([rsrv_in.to_i, rsrv_out.to_i].min / 1024) * 8

        end

        network = self["runtime.host.network"].select do |n|

            n.name == bridge

        end

        if network.empty?

            raise "Network #{bridge} not found in host #{self['runtime.host.name']}"

        else

            network = network.first

        end

        card_num = 1 # start in one, we want the next avaliable id

        self["config.hardware.device"].each do |dv|

            card_num += 1 if is_nic?(dv)

        end

        nic_card = case model

                        when "virtuale1000", "e1000"

                            RbVmomi::VIM::VirtualE1000

                        when "virtuale1000e", "e1000e"

                            RbVmomi::VIM::VirtualE1000e

                        when "virtualpcnet32", "pcnet32"

                            RbVmomi::VIM::VirtualPCNet32

                        when "virtualsriovethernetcard", "sriovethernetcard"

                            RbVmomi::VIM::VirtualSriovEthernetCard

                        when "virtualvmxnetm", "vmxnetm"

                            RbVmomi::VIM::VirtualVmxnetm

                        when "virtualvmxnet2", "vmnet2"

                            RbVmomi::VIM::VirtualVmxnet2

                        when "virtualvmxnet3", "vmxnet3"

                            RbVmomi::VIM::VirtualVmxnet3

                        else # If none matches, use VirtualE1000

                            RbVmomi::VIM::VirtualE1000

        if network.class == RbVmomi::VIM::Network

            backing = RbVmomi::VIM.VirtualEthernetCardNetworkBackingInfo(

                        :deviceName => bridge,

                        :network    => network)

        else

            port    = RbVmomi::VIM::DistributedVirtualSwitchPortConnection(

                        :switchUuid =>

                                network.config.distributedVirtualSwitch.uuid,

                        :portgroupKey => network.key)

            backing =

              RbVmomi::VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(

                 :port => port)

        end

        card_spec = {

            :key => 0,

            :deviceInfo => {

                :label => "net" + card_num.to_s,

                :summary => bridge

            },

            :backing     => backing,

            :addressType => mac ? 'manual' : 'generated',

            :macAddress  => mac

        }

        if (limit || rsrv) && (limit > 0)

            ra_spec = {}

            rsrv = limit if rsrv > limit

            ra_spec[:limit] = limit if limit

            ra_spec[:reservation] = rsrv if rsrv

            ra_spec[:share] =  RbVmomi::VIM.SharesInfo({

                    :level => RbVmomi::VIM.SharesLevel("normal"),

                    :shares => 0

                })

            card_spec[:resourceAllocation] =

               RbVmomi::VIM.VirtualEthernetCardResourceAllocation(ra_spec)

        end

        {

            :operation => :add,

            :device    => nic_card.new(card_spec)

        }

    end

    #  Checks if a RbVmomi::VIM::VirtualDevice is a network interface

    def is_nic?(device)

        !device.class.ancestors.index(RbVmomi::VIM::VirtualEthernetCard).nil?

    end

    def device_change_disks

        disks = []

        one_item.each("TEMPLATE/DISK") { |disk| disks << disk }

        if !is_new?

            self["config.hardware.device"].each do |d|

                if is_disk_or_cdrom?(d)

                    disks.each do |disk|

                        if d.backing.respond_to?(:fileName) &&

                            get_img_name(disk) == d.backing.fileName

                            disks.delete(disk)

                        end

                    end

            end

        end

        return if disks.nil?

        position = 0

        attach_disk_array = []

        disks.each do |disk|

            attach_disk_array << calculate_add_disk_spec(disk)

            position += 1

        end

        attach_disk_array

    end

    def calculate_add_disk_spec(disk, position=0)

        img_name = get_img_name(disk)

        ds       = get_effective_ds(disk)

        ds_name  = ds['name']

        type     = disk["TYPE"]

        # TODO: size_kb = 0 ??

        size_kb = 0

        controller, new_number = find_free_controller(position)

        if type == "CDROM"

            vmdk_backing = RbVmomi::VIM::VirtualCdromIsoBackingInfo(

                :datastore => ds.item,

                :fileName  => "[#{ds_name}] #{img_name}"

            )

            cd = self['config.hardware.device'].select  do |hw|

                hw.class == RbVmomi::VIM::VirtualCdrom

            end.first

            # If no CDROM drive present, we need to add it

            if !cd

                controller, _ = find_free_controller

                device = RbVmomi::VIM::VirtualCdrom(

                    :backing       => vmdk_backing,

                    :key           => -1,

                    :controllerKey => 15000,

                    :unitNumber    => 0,

                    :connectable => RbVmomi::VIM::VirtualDeviceConnectInfo(

                        :startConnected    => true,

                        :connected         => true,

                        :allowGuestControl => true

                    )

                )

                return {

                    :operation => :add,

                    :device => device

                }

            else

                device = RbVmomi::VIM::VirtualCdrom(

                    backing: vmdk_backing,

                    key: cd.key,

                    controllerKey: cd.controllerKey,

                    connectable: RbVmomi::VIM::VirtualDeviceConnectInfo(

                        startConnected: true,

                        connected: true,

                        allowGuestControl: true

                    )

                )

                return {

                   :operation => :edit,

                   :device    => device

                }

            end

        else

            # TYPE is regular disk (not CDROM)

            vmdk_backing = RbVmomi::VIM::VirtualDiskFlatVer2BackingInfo(

                  :datastore => ds.item,

                  :diskMode  => 'persistent',

                  :fileName  => "[#{ds_name}] #{img_name}"

            )

            device = RbVmomi::VIM::VirtualDisk(

              :backing       => vmdk_backing,

              :capacityInKB  => size_kb,

              :controllerKey => controller.key,

              :key           => -1,

              :unitNumber    => new_number

            )

            {

               :operation => :add,

               :device    => device

        end

    end

    #  Checks if a RbVmomi::VIM::VirtualDevice is a disk

    def is_disk_or_cdrom?(device)

        is_disk  = !(device.class.ancestors.index(RbVmomi::VIM::VirtualDisk)).nil?

        is_cdrom = !(device.class.ancestors.index(RbVmomi::VIM::VirtualCdrom)).nil?

        is_disk || is_cdrom

    end

    def find_free_controller(position=0)

        free_scsi_controllers = []

        available_controller  = nil

        scsi_schema           = {}

        used_numbers      = []

        available_numbers = []

        self["config.hardware.device"].each do |dev|

            if dev.is_a? RbVmomi::VIM::VirtualSCSIController

                if scsi_schema[dev.controllerKey].nil?

                    scsi_schema[dev.key] = {}

                end

                used_numbers << dev.scsiCtlrUnitNumber

                scsi_schema[dev.key][:device] = dev

          end

            next if dev.class != RbVmomi::VIM::VirtualDisk

            used_numbers << dev.unitNumber

        end

        15.times do |scsi_id|

            available_numbers << scsi_id if used_numbers.grep(scsi_id).length <= 0

        scsi_schema.keys.each do |controller|

            free_scsi_controllers << scsi_schema[controller][:device].deviceInfo.label

        end

        if free_scsi_controllers.length > 0

            available_controller_label = free_scsi_controllers[0]

        else

            add_new_scsi(scsi_schema)

            return find_free_controller

        end

        controller = nil

        self['config.hardware.device'].each do |device|

            if device.deviceInfo.label == available_controller_label

                controller = device

                break

            end

        new_unit_number = available_numbers.sort[position]

        return controller, new_unit_number

    def add_new_scsi(scsi_schema)

        controller = nil

        if scsi_schema.keys.length >= 4

            raise "Cannot add a new controller, maximum is 4."

        end

        if scsi_schema.keys.length == 0

            scsi_key    = 0

            scsi_number = 0

        else scsi_schema.keys.length < 4

            scsi_key    = scsi_schema.keys.sort[-1] + 1

            scsi_number = scsi_schema[scsi_schema.keys.sort[-1]][:device].busNumber + 1

        controller_device = RbVmomi::VIM::VirtualLsiLogicController(

            :key       => scsi_key,

            :busNumber => scsi_number,

            :sharedBus => :noSharing

        )

        device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(

            :device    => controller_device,

            :operation => :add

        )

        vm_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec(

            :deviceChange => [device_config_spec]

        )

        self.item.ReconfigVM_Task(:spec => vm_config_spec).wait_for_completion

        self["config.hardware.device"].each do |device|

            if device.class == RbVmomi::VIM::VirtualLsiLogicController &&

                device.key == scsi_key

                controller = device.deviceInfo.label

            end

        end

        return controller

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

    # actions

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

        self.item.PowerOnVM_Task.wait_for_completion

        value = state ? "yes" : "no"

        config_array = [

            { :key => "opennebula.vm.running", :value => value }

        ]

        spec = RbVmomi::VIM.VirtualMachineConfigSpec(

            { :extraConfig => config_array }

        )

        self.item.ReconfigVM_Task(:spec => spec).wait_for_completion

    # monitoring