opennebula 5.12.13 → 5.13.80.pre

data/lib/datastore.rb

@@ -0,0 +1,1025 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2021, 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.                                             #
+#--------------------------------------------------------------------------- #
+
+##############################################################################
+# Module VCenterDriver
+##############################################################################
+module VCenterDriver
+
+    require 'digest'
+    require 'uri'
+
+    ##########################################################################
+    # Class DatastoreFolder
+    ##########################################################################
+    class DatastoreFolder
+
+        attr_accessor :item, :items
+
+        def initialize(item)
+            @item = item
+            @items = {}
+        end
+
+        ######################################################################
+        # Builds a hash with Datastore-Ref / Datastore to be used as a cache
+        # @return [Hash] in the form
+        #   { ds_ref [Symbol] => Datastore object }
+        ######################################################################
+        def fetch!
+            VIClient.get_entities(@item, 'Datastore').each do |item|
+                item_name = item._ref
+                @items[item_name.to_sym] = Datastore.new(item)
+            end
+
+            VIClient.get_entities(@item, 'StoragePod').each do |sp|
+                @items[sp._ref.to_sym] = StoragePod.new(sp)
+                VIClient.get_entities(sp, 'Datastore').each do |item|
+                    item_name = item._ref
+                    @items[item_name.to_sym] = Datastore.new(item)
+                end
+            end
+            @items
+        end
+
+        ######################################################################
+        # Returns a Datastore or StoragePod. Uses the cache if available.
+        # @param ref [Symbol] the vcenter ref
+        # @return Datastore
+        ######################################################################
+        def get(ref)
+            if !@items[ref.to_sym]
+                if ref.start_with?('group-')
+                    rbvmomi_spod = RbVmomi::VIM::StoragePod
+                                   .new(
+                                       @item._connection,
+                                       ref
+                                   ) rescue nil
+                    @items[ref.to_sym] = StoragePod.new(rbvmomi_spod)
+                else
+                    rbvmomi_ds = RbVmomi::VIM::Datastore
+                                 .new(
+                                     @item._connection,
+                                     ref
+                                 ) rescue nil
+                    @items[ref.to_sym] = Datastore.new(rbvmomi_ds)
+                end
+            end
+            @items[ref.to_sym]
+        end
+
+    end
+    # class DatastoreFolder
+
+    ##########################################################################
+    # Class Storage
+    ##########################################################################
+    class Storage
+
+        attr_accessor :item
+
+        include Memoize
+
+        CURLBIN = 'curl'
+
+        def self.new_from_ref(ref, vi_client)
+            if ref.start_with?('group-')
+                VCenterDriver::StoragePod.new_from_ref(ref, vi_client)
+            else
+                VCenterDriver::Datastore.new_from_ref(ref, vi_client)
+            end
+        end
+
+        def self.get_image_import_template(params)
+            disk = params[:disk]
+            ipool = params[:ipool]
+            _type = params[:_type]
+            ds_id = params[:ds_id]
+            opts = params[:opts]
+            images = params[:images]
+
+            VCenterDriver::VIHelper.check_opts(opts, [:persistent])
+
+            ds_name      = disk[:datastore].name
+            image_path   = disk[:path_wo_ds]
+            image_type   = disk[:type]
+            image_prefix = disk[:prefix]
+
+            image_name = nil
+
+            one_image = {}
+            one_image[:template] = ''
+
+            # Get image name
+            file_name = File.basename(image_path).gsub(/\.vmdk$/, '')
+
+            # Check if the image has already been imported
+            image = VIHelper
+                    .find_image_by(
+                        'SOURCE',
+                        OpenNebula::ImagePool,
+                        image_path,
+                        ds_id,
+                        ipool
+                    )
+
+            if image.nil?
+                key = "#{file_name}#{ds_name}#{image_path}"
+                byte = 0
+                image_name = VCenterDriver::VIHelper
+                             .one_name(
+                                 OpenNebula::ImagePool,
+                                 file_name,
+                                 key,
+                                 ipool,
+                                 byte
+                             )
+                while images.include?(image_name)
+                    byte += 2
+                    image_name = VCenterDriver::VIHelper
+                                 .one_name(
+                                     OpenNebula::ImagePool,
+                                     file_name,
+                                     key,
+                                     ipool,
+                                     byte
+                                 )
+                end
+
+                # Set template
+                one_image[:template] << "NAME=\"#{image_name}\"\n"
+                one_image[:template] << "PATH=\"vcenter://#{image_path}\"\n"
+                one_image[:template] << "TYPE=\"#{image_type}\"\n"
+                one_image[:template] << "PERSISTENT=\"#{opts[:persistent]}\"\n"
+                unless CONFIG[:delete_images]
+                    one_image[:template] << "VCENTER_IMPORTED=\"YES\"\n"
+                end
+                one_image[:template] << "DEV_PREFIX=\"#{image_prefix}\"\n"
+            else
+                # Return the image XML if it already exists
+                one_image[:one] = image
+            end
+
+            [one_image, image_name]
+        end
+
+        def self.get_one_image_ds_by_ref_and_dc(
+            ref,
+            dc_ref,
+            vcenter_uuid,
+            pool = nil
+        )
+            if pool.nil?
+                pool = VCenterDriver::VIHelper
+                       .one_pool(
+                           OpenNebula::DatastorePool,
+                           false
+                       )
+                if pool.respond_to?(:message)
+                    raise "Could not get \
+                    OpenNebula DatastorePool: #{pool.message}"
+                end
+            end
+
+            pool.select do |e|
+                e['TEMPLATE/TYPE'] == 'IMAGE_DS' &&
+                    e['TEMPLATE/VCENTER_DS_REF']      == ref &&
+                    e['TEMPLATE/VCENTER_DC_REF']      == dc_ref &&
+                    e['TEMPLATE/VCENTER_INSTANCE_ID'] == vcenter_uuid
+            end.first rescue nil
+        end
+
+        #  Checks if a RbVmomi::VIM::VirtualDevice is a disk or an iso file
+        def self.disk_or_iso?(device)
+            is_disk = !device.class.ancestors.index(
+                RbVmomi::VIM::VirtualDisk
+            ).nil?
+            is_iso = device
+                     .backing.is_a? RbVmomi::VIM::VirtualCdromIsoBackingInfo
+            is_disk || is_iso
+        end
+
+        def monitor
+            summary = self['summary']
+
+            total_mb = (summary.capacity.to_i / 1024) / 1024
+            free_mb  = (summary.freeSpace.to_i / 1024) / 1024
+            used_mb  = total_mb - free_mb
+
+            "USED_MB=#{used_mb}\nFREE_MB=#{free_mb} \nTOTAL_MB=#{total_mb}"
+        end
+
+        def self.exists_one_by_ref_dc_and_type?(
+            ref,
+            dc_ref,
+            vcenter_uuid,
+            type,
+            pool = nil
+        )
+            if pool.nil?
+                pool = VCenterDriver::VIHelper.one_pool(
+                    OpenNebula::DatastorePool,
+                    false
+                )
+                if pool.respond_to?(:message)
+                    raise "Could not get OpenNebula \
+                    DatastorePool: #{pool.message}"
+                end
+            end
+            elements = pool.select do |e|
+                e['TEMPLATE/TYPE'] == type &&
+                    e['TEMPLATE/VCENTER_DS_REF'] == ref &&
+                    e['TEMPLATE/VCENTER_DC_REF'] == dc_ref &&
+                    e['TEMPLATE/VCENTER_INSTANCE_ID'] == vcenter_uuid
+            end
+
+            elements.size == 1
+        end
+
+        def to_one(ds_hash, vcenter_uuid, dc_name, dc_ref)
+            one = ''
+            one << "DRIVER=\"vcenter\"\n"
+            one << "NAME=\"#{ds_hash[:name]}\"\n"
+            one << "TM_MAD=vcenter\n"
+            one << "VCENTER_INSTANCE_ID=\"#{vcenter_uuid}\"\n"
+            one << "VCENTER_DC_REF=\"#{dc_ref}\"\n"
+            one << "VCENTER_DC_NAME=\"#{dc_name}\"\n"
+            one << "VCENTER_DS_NAME=\"#{ds_hash[:simple_name]}\"\n"
+            one << "VCENTER_DS_REF=\"#{self['_ref']}\"\n"
+            one
+        end
+
+        def to_one_template(ds_hash, vcenter_uuid, dc_name, dc_ref, type)
+            one_tmp = {
+                :one  => to_one(ds_hash, vcenter_uuid, dc_name, dc_ref)
+            }
+
+            if type == 'SYSTEM_DS'
+                one_tmp[:one] << "TYPE=SYSTEM_DS\n"
+            else
+                one_tmp[:one] << "DS_MAD=vcenter\n"
+                one_tmp[:one] << "TYPE=IMAGE_DS\n"
+            end
+
+            one_tmp
+        end
+
+        def create_virtual_disk(img_name, size, adapter_type, disk_type)
+            leading_dirs = img_name.split('/')[0..-2]
+            if !leading_dirs.empty?
+                create_directory(leading_dirs.join('/'))
+            end
+
+            ds_name = self['name']
+
+            vmdk_spec = RbVmomi::VIM::FileBackedVirtualDiskSpec(
+                :adapterType => adapter_type,
+                :capacityKb  => size.to_i*1024,
+                :diskType    => disk_type
+            )
+
+            obtain_vdm.CreateVirtualDisk_Task(
+                :datacenter => obtain_dc.item,
+                :name       => "[#{ds_name}] #{img_name}.vmdk",
+                :spec       => vmdk_spec
+            ).wait_for_completion
+
+            "#{img_name}.vmdk"
+        end
+
+        def create_directory(directory)
+            ds_name = self['name']
+
+            return if self.class == VCenterDriver::StoragePod
+
+            directory_name = "[#{ds_name}] #{directory}"
+
+            create_directory_params = {
+                :name                     => directory_name,
+                :datacenter               => obtain_dc.item,
+                :createParentDirectories  => true
+            }
+
+            obtain_fm.MakeDirectory(create_directory_params) rescue nil
+        end
+
+        def obtain_fm
+            self['_connection.serviceContent.fileManager']
+        end
+
+        def obtain_vdm
+            self['_connection.serviceContent.virtualDiskManager']
+        end
+
+        def obtain_dc
+            item = @item
+
+            until item.instance_of? RbVmomi::VIM::Datacenter
+                item = item.parent
+                if item.nil?
+                    raise 'Could not find the parent Datacenter'
+                end
+            end
+
+            Datacenter.new(item)
+        end
+
+    end
+    # class Storage
+
+    ########################################################################
+    # Class StoragePod
+    ########################################################################
+    class StoragePod < Storage
+
+        def initialize(item, _vi_client = nil)
+            check_item(item, RbVmomi::VIM::StoragePod)
+            @item = item
+
+            super()
+        end
+
+        # This is never cached
+        def self.new_from_ref(ref, vi_client)
+            new(RbVmomi::VIM::StoragePod.new(vi_client.vim, ref), vi_client)
+        end
+
+    end
+    # class StoragePod
+
+    ##########################################################################
+    # Class Datastore
+    ##########################################################################
+    class Datastore < Storage
+
+        attr_accessor :one_item
+
+        def initialize(item, vi_client = nil)
+            check_item(item, RbVmomi::VIM::Datastore)
+            @vi_client = vi_client
+            @item = item
+            @one_item = {}
+
+            super()
+        end
+
+        def delete_virtual_disk(img_name)
+            ds_name = self['name']
+
+            begin
+                obtain_vdm.DeleteVirtualDisk_Task(
+                    :name => "[#{ds_name}] #{img_name}",
+                    :datacenter => obtain_dc.item
+                ).wait_for_completion
+            rescue StandardError => e
+                # Ignore if file not found
+                if !e.message.start_with?('ManagedObjectNotFound') &&
+                   !e.message.start_with?('FileNotFound')
+                    raise e
+                end
+            end
+        end
+
+        def delete_file(img_name)
+            ds_name = self['name']
+
+            begin
+                obtain_fm.DeleteDatastoreFile_Task(
+                    :name => "[#{ds_name}] #{img_name}",
+                    :datacenter => obtain_dc.item
+                ).wait_for_completion
+            rescue StandardError => e
+                # Ignore if file not found
+                if !e.message.start_with?('ManagedObjectNotFound') &&
+                   !e.message.start_with?('FileNotFound')
+                    raise e
+                end
+            end
+        end
+
+        # Copy a VirtualDisk
+        def copy_virtual_disk(src_path, target_ds, target_path, new_size = nil)
+            source_ds_name = self['name']
+            target_ds_name = target_ds['name']
+
+            leading_dirs = target_path.split('/')[0..-2]
+            if !leading_dirs.empty?
+                if source_ds_name == target_ds_name
+                    create_directory(leading_dirs.join('/'))
+                else
+                    target_ds.create_directory(leading_dirs.join('/'))
+                end
+            end
+
+            copy_params = {
+                :sourceName        => "[#{source_ds_name}] #{src_path}",
+                :sourceDatacenter  => obtain_dc.item
+            }
+
+            if File.extname(src_path) == '.vmdk'
+                copy_params[:destName] = "[#{target_ds_name}] #{target_path}"
+                obtain_vdm.CopyVirtualDisk_Task(copy_params).wait_for_completion
+
+                if new_size
+                    resize_spec = {
+                        :name => "[#{target_ds_name}] #{target_path}",
+                        :datacenter => target_ds.obtain_dc.item,
+                        :newCapacityKb => new_size,
+                        :eagerZero => false
+                    }
+
+                    obtain_vdm.ExtendVirtualDisk_Task(
+                        resize_spec
+                    ).wait_for_completion
+                end
+            else
+                copy_params[:destinationName] =
+                    "[#{target_ds_name}] #{target_path}"
+                obtain_fm.CopyDatastoreFile_Task(
+                    copy_params
+                ).wait_for_completion
+            end
+
+            target_path
+        end
+
+        def move_virtual_disk(disk, dest_path, dest_dsid, vi_client = nil)
+            vi_client ||= @vi_client
+
+            target_ds     = VCenterDriver::VIHelper.one_item(
+                OpenNebula::Datastore,
+                dest_dsid,
+                false
+            )
+            target_ds_ref = target_ds['TEMPLATE/VCENTER_DS_REF']
+            target_ds_vc  = VCenterDriver::Datastore
+                            .new_from_ref(
+                                target_ds_ref,
+                                vi_client
+                            )
+            dest_name = target_ds_vc['name']
+
+            target_ds_vc.create_directory(File.dirname(dest_path))
+
+            dpath_ds  = "[#{dest_name}] #{dest_path}"
+            orig_path = "[#{self['name']}] #{disk.path}"
+
+            move_params = {
+                :sourceName => orig_path,
+                :sourceDatacenter => obtain_dc.item,
+                :destName => dpath_ds,
+                :force => true
+            }
+
+            obtain_vdm.MoveVirtualDisk_Task(move_params).wait_for_completion
+        end
+
+        def rm_directory(directory)
+            ds_name = self['name']
+
+            rm_directory_params = {
+                :name                     => "[#{ds_name}] #{directory}",
+                :datacenter               => obtain_dc.item
+            }
+
+            obtain_fm.DeleteDatastoreFile_Task(
+                rm_directory_params
+            ).wait_for_completion
+        end
+
+        def dir_empty?(path)
+            ds_name = self['name']
+
+            spec = RbVmomi::VIM::HostDatastoreBrowserSearchSpec.new
+
+            search_params = {
+                'datastorePath' => "[#{ds_name}] #{path}",
+                'searchSpec'    => spec
+            }
+
+            begin
+                search_task = self['browser']
+                              .SearchDatastoreSubFolders_Task(search_params)
+                search_task.wait_for_completion
+                !search_task.info.result.nil? &&
+                    search_task.info.result.length == 1 &&
+                    search_task.info.result.first.file.empty?
+            rescue StandardError
+                false
+            end
+        end
+
+        def upload_file(source_path, target_path)
+            @item.upload(target_path, source_path)
+        end
+
+        def download_file(source_path, target_path)
+            @item.download(source_path, target_path)
+        end
+
+        # Get file size for image handling
+        def stat(img_str)
+            ds_name = self['name']
+            img_path = File.dirname img_str
+            img_name = File.basename img_str
+
+            # Create Search Spec
+            search_params = get_search_params(ds_name, img_path, img_name)
+
+            # Perform search task and return results
+            begin
+                search_task = self['browser']
+                              .SearchDatastoreSubFolders_Task(search_params)
+
+                search_task.wait_for_completion
+
+                # Try to get vmdk capacity as seen by VM
+                size = search_task
+                       .info.result[0].file[0].capacityKb / 1024 rescue nil
+
+                # Try to get file size
+                size ||= search_task
+                         .info
+                         .result[0].file[0].fileSize / 1024 / 1024 rescue nil
+
+                raise 'Could not get file size or capacity' if size.nil?
+
+                size
+            rescue StandardError
+                raise 'Could not find file.'
+            end
+        end
+
+        def get_search_params(ds_name, img_path = nil, img_name = nil)
+            spec         = RbVmomi::VIM::HostDatastoreBrowserSearchSpec.new
+
+            vmdisk_query = RbVmomi::VIM::VmDiskFileQuery.new
+            vmdisk_query.details = RbVmomi::VIM::VmDiskFileQueryFlags(
+                :diskType        => true,
+                :capacityKb      => true,
+                :hardwareVersion => true,
+                :controllerType  => true
+            )
+
+            spec.query   = [vmdisk_query,
+                            RbVmomi::VIM::IsoImageFileQuery.new]
+            spec.details = RbVmomi::VIM::FileQueryFlags(
+                :fileOwner    => true,
+                :fileSize     => true,
+                :fileType     => true,
+                :modification => true
+            )
+
+            if img_name.nil?
+                spec.matchPattern = []
+            else
+                spec.matchPattern = [img_name]
+            end
+
+            datastore_path = "[#{ds_name}]"
+            datastore_path << " #{img_path}" unless img_path.nil?
+
+            { 'datastorePath' => datastore_path,
+                             'searchSpec'    => spec }
+        end
+
+        def dc_path
+            dc = obtain_dc
+            p = dc.item.parent
+            path = [dc.item.name]
+            while p.instance_of? RbVmomi::VIM::Folder
+                path.unshift(p.name)
+                p = p.parent
+            end
+            path.delete_at(0) # The first folder is the root "Datacenters"
+            path.join('/')
+        end
+
+        def generate_file_url(path)
+            if self['_connection.http.use_ssl?']
+                protocol = 'https://'
+            else
+                protocol = 'http://'
+            end
+            hostname = self['_connection.http.address']
+            port     = self['_connection.http.port']
+            dcpath   = dc_path
+            url_path = "folder/#{path}?dcPath=#{dcpath}&dsName=#{self['name']}"
+
+            # This creates the vcenter file URL
+            # for uploading or downloading files
+            # e.g:
+            url = "#{protocol}#{hostname}:#{port}/#{url_path}"
+            URI.escape(url) # rubocop:disable Lint/UriEscapeUnescape
+        end
+
+        def download_to_stdout(remote_path)
+            url = generate_file_url(remote_path)
+            pid = spawn(CURLBIN,
+                        '-k', '--noproxy', '*', '-f',
+                        '-b', self['_connection.cookie'],
+                        url)
+
+            Process.waitpid(pid, 0)
+            raise 'download failed' unless $?.success? # rubocop:disable Style/SpecialGlobalVars
+        end
+
+        def descriptor?(remote_path)
+            url = generate_file_url(remote_path)
+
+            rout, wout = IO.pipe
+            pid = spawn(CURLBIN,
+                        '-I', '-k', '--noproxy', '*', '-f',
+                        '-b', self['_connection.cookie'],
+                        url,
+                        :out => wout,
+                        :err => '/dev/null')
+
+            Process.waitpid(pid, 0)
+            raise 'read image header failed' unless $?.success? # rubocop:disable Style/SpecialGlobalVars
+
+            wout.close
+            size = rout.readlines.select do |l|
+                l.start_with?('Content-Length')
+            end[0].sub('Content-Length: ', '')
+            rout.close
+            size.chomp.to_i < 4096 # If <4k, then is a descriptor
+        end
+
+        def get_text_file(remote_path)
+            url = generate_file_url(remote_path)
+
+            rout, wout = IO.pipe
+            pid = spawn CURLBIN, '-k', '--noproxy', '*', '-f',
+                        '-b', self['_connection.cookie'],
+                        url,
+                        :out => wout,
+                        :err => '/dev/null'
+
+            Process.waitpid(pid, 0)
+            raise 'get text file failed' unless $?.success? # rubocop:disable Style/SpecialGlobalVars
+
+            wout.close
+            output = rout.readlines
+            rout.close
+            output
+        end
+
+        def all_images
+            images = {}
+            imid = -1
+            ds_id = nil
+            ds_name = self['name']
+
+            # We need OpenNebula Images and Datastores pools
+            ipool = VCenterDriver::VIHelper
+                    .one_pool(OpenNebula::ImagePool, false)
+            if ipool.respond_to?(:message)
+                raise "Could not get OpenNebula ImagePool: #{pool.message}"
+            end
+
+            dpool = VCenterDriver::VIHelper
+                    .one_pool(OpenNebula::DatastorePool, false)
+            if dpool.respond_to?(:message)
+                raise "Could not get OpenNebula DatastorePool: #{pool.message}"
+            end
+
+            ds_id = @one_item['ID']
+
+            begin
+                # Create Search Spec
+                search_params = get_search_params(ds_name)
+
+                # Perform search task and return results
+                search_task = self['browser']
+                              .SearchDatastoreSubFolders_Task(search_params)
+                search_task.wait_for_completion
+
+                # Loop through search results
+                search_task.info.result.each do |result|
+                    # Remove [datastore] from file path
+                    folderpath = ''
+                    size = result.folderPath.size
+                    if result.folderPath[-1] != ']'
+                        if result.folderPath[-1] != '/'
+                            result.folderPath[size] = '/'
+                        end
+                        folderpath = result
+                                     .folderPath.sub(/^\[#{ds_name}\] /, '')
+                    end
+
+                    # Loop through images in result.file
+                    result.file.each do |image|
+                        image_path = ''
+
+                        # Skip not relevant files
+                        next unless %w[FloppyImageFileInfo
+                                       IsoImageFileInfo
+                                       VmDiskFileInfo].include? image.class.to_s
+
+                        # Get image path and name
+                        image_path << folderpath << image.path
+                        image_name = File.basename(image.path)
+                                         .reverse.sub('kdmv.', '').reverse
+
+                        # Get image's type
+                        if image.class.to_s == 'VmDiskFileInfo'
+                            image_type = 'OS'
+                        else
+                            image_type = 'CDROM'
+                        end
+
+                        # Get image's size
+                        image_size = image.capacityKb / 1024 rescue nil
+                        image_size ||= image.fileSize / 1024 / 1024 rescue nil
+
+                        # Assign image prefix if known or assign default prefix
+                        controller = image.controllerType rescue nil
+                        if controller
+                            if controller == 'VirtualIDEController'
+                                disk_prefix = 'hd'
+                            else
+                                disk_prefix = 'sd'
+                            end
+                        else
+                            # Get default value for disks that
+                            # are not attached to any controller
+                            disk_prefix = VCenterDriver::VIHelper
+                                          .get_default(
+                                              'IMAGE/TEMPLATE/DEV_PREFIX'
+                                          )
+                        end
+
+                        # Generate a crypto hash
+                        # this hash is used to avoid name collisions
+                        key = "#{image_name}#{ds_name}#{image_path}"
+                        import_name = VCenterDriver::VIHelper
+                                      .one_name(
+                                          OpenNebula::ImagePool,
+                                          image_name,
+                                          key,
+                                          ipool
+                                      )
+
+                        # Set template
+                        one_image =  "NAME=\"#{import_name}\"\n"
+                        one_image << "PATH=\"vcenter://#{image_path}\"\n"
+                        one_image << "PERSISTENT=\"NO\"\n"
+                        one_image << "TYPE=\"#{image_type}\"\n"
+                        unless CONFIG[:delete_images]
+                            one_image << "VCENTER_IMPORTED=\"YES\"\n"
+                        end
+                        one_image << "DEV_PREFIX=\"#{disk_prefix}\"\n"
+
+                        # Check image hasn't already been imported
+                        image_found = VCenterDriver::VIHelper
+                                      .find_image_by(
+                                          'SOURCE',
+                                          OpenNebula::ImagePool,
+                                          image_path,
+                                          ds_id,
+                                          ipool
+                                      )
+
+                        next if image_found
+
+                        # Add template to image array
+                        images[import_name] = {
+                            :import_id   => imid+=1,
+                            :name        => import_name,
+                            :ref         => import_name,
+                            :path        => image_path,
+                            :size        => image_size.to_s,
+                            :type        => image.class.to_s,
+                            :dsid        => ds_id,
+                            :one         => one_image
+                        }
+                    end
+                end
+            rescue StandardError => e
+                raise "Could not find images. \
+                      Reason: #{e.message}/#{e.backtrace}"
+            end
+            vname = @vi_client.vc_name || ''
+
+            { vname => images }
+        end
+
+        # This is never cached
+        def self.new_from_ref(ref, vi_client)
+            new(RbVmomi::VIM::Datastore.new(vi_client.vim, ref), vi_client)
+        end
+
+        # detach disk from vCenter vm if possible, destroy the disk on FS
+        def self.detach_and_destroy(disk, vm, disk_id, prev_ds_ref, vi_client)
+            # it's not a CDROM (CLONE=NO)
+            is_cd = !(disk['CLONE'].nil? || disk['CLONE'] == 'YES')
+
+            begin
+                # Detach disk if possible (VM is reconfigured)
+                # and gather vCenter info
+                # Needed for poweroff machines too
+                ds_ref, img_path = vm.detach_disk(disk)
+
+                return if is_cd
+
+                # Disk could't be detached, use OpenNebula info
+                if !(ds_ref && img_path && !img_path.empty?)
+                    img_path = vm.disk_real_path(disk, disk_id)
+                    ds_ref = prev_ds_ref
+                end
+
+                # If disk was already detached we have no way to remove it
+                ds = VCenterDriver::Datastore.new_from_ref(ds_ref, vi_client)
+
+                search_params = ds.get_search_params(ds['name'],
+                                                     File.dirname(img_path),
+                                                     File.basename(img_path))
+
+                # Perform search task and return results
+                search_task = ds['browser']
+                              .SearchDatastoreSubFolders_Task(search_params)
+                search_task.wait_for_completion
+
+                ds.delete_virtual_disk(img_path)
+                img_dir = File.dirname(img_path)
+                ds.rm_directory(img_dir) if ds.dir_empty?(img_dir)
+            rescue StandardError => e
+                if !e.message.start_with?('FileNotFound')
+                    raise e.message # Ignore FileNotFound
+                end
+            end
+        end
+
+    end
+    # class Datastore
+
+    ##########################################################################
+    # Class DsImporter
+    ##########################################################################
+    class DsImporter < VCenterDriver::VcImporter
+
+        def initialize(one_client, vi_client)
+            super(one_client, vi_client)
+            @one_class = OpenNebula::Datastore
+        end
+
+        def get_list(_args = {})
+            dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
+
+            # one pool creation
+            dpool = VCenterDriver::VIHelper
+                    .one_pool(
+                        OpenNebula::DatastorePool,
+                        false
+                    )
+            if dpool.respond_to?(:message)
+                raise "Could not get OpenNebula DatastorePool: #{dpool.message}"
+            end
+
+            # OpenNebula's HostPool
+            hpool = VCenterDriver::VIHelper
+                    .one_pool(
+                        OpenNebula::HostPool,
+                        false
+                    )
+            if hpool.respond_to?(:message)
+                raise "Could not get OpenNebula HostPool: #{hpool.message}"
+            end
+
+            rs = dc_folder
+                 .get_unimported_datastores(
+                     dpool,
+                     @vi_client.vc_name,
+                     hpool
+                 )
+            @list = rs
+        end
+
+        def add_cluster(cid, eid)
+            one_cluster = @info[:clusters][cid]
+            raise 'no cluster defined' unless one_cluster
+
+            one_cluster.adddatastore(eid)
+        end
+
+        def remove_default(id)
+            cid = 0
+            @info[:clusters][cid] ||= VCenterDriver::VIHelper
+                                      .one_item(
+                                          OpenNebula::Cluster,
+                                          cid.to_s,
+                                          false
+                                      )
+            @info[:clusters][cid].deldatastore(id.to_i)
+        end
+
+        def import(selected)
+            inner = lambda {|object, auth|
+                one = ''
+                one << "VCENTER_HOST=\"#{auth[:host]}\"\n"
+
+                object.update(one, true)
+            }
+
+            opts = @info[selected[:ref]][:opts]
+
+            # Datastore info comes in a pair (SYS, IMG)
+            pair     = selected[:ds]
+            clusters = selected[:cluster]
+            if opts && opts['selected_clusters']
+                clusters = opts['selected_clusters'].each.map(&:to_i)
+            end
+
+            res = { :id => [], :name => selected[:simple_name] }
+            @info[:rollback] = []
+            pair.each do |ds|
+                create(ds[:one]) do |one_object, id|
+                    res[:id] << id
+
+                    add_clusters(id, clusters)
+
+                    inner.call(
+                        one_object,
+                        @vi_client.host_credentials(
+                            @one_client
+                        )
+                    )
+                end
+            end
+
+            res
+        end
+
+    end
+
+    ##########################################################################
+    # Class ImageImporter
+    ##########################################################################
+    class ImageImporter < VCenterDriver::VcImporter
+
+        def initialize(one_client, vi_client)
+            super(one_client, vi_client)
+            @one_class = OpenNebula::Image
+        end
+
+        def get_list(args = {})
+            ds_ref   = args[:datastore][:ds_ref]
+            one_ds   = args[:datastore][:one_item]
+
+            unless ds_ref
+                raise "can't retrieve ref info from openNebula datastore"
+            end
+
+            datastore = VCenterDriver::Datastore
+                        .new_from_ref(ds_ref, @vi_client)
+
+            ds = datastore.tap do |spawn|
+                spawn.one_item = one_ds
+            end
+
+            vc_uuid = @vi_client.vim.serviceContent.about.instanceUuid
+            one_ds_instance_id = one_ds['TEMPLATE/VCENTER_INSTANCE_ID']
+
+            if one_ds_instance_id != vc_uuid
+                raise 'Datastore is not in the same vCenter \
+                    instance provided in credentials'
+            end
+
+            @list = ds.all_images
+        end
+
+        def import(selected)
+            resource = VCenterDriver::VIHelper.new_one_item(@one_class)
+            message = 'Error creating the OpenNebula resource'
+            info = selected[:one]
+            dsid = selected[:dsid].to_i
+            name = selected[:name]
+
+            rc = resource.allocate(info, dsid, false)
+            VCenterDriver::VIHelper.check_error(rc, message)
+
+            resource.info
+            id = resource['ID']
+            @rollback << Raction.new(resource, :delete)
+
+            { :id => [id], :name => name }
+        end
+
+    end
+
+end
+# module VCenterDriver