class VCenterDriver::Storage

Class Storage

Constants

CURLBIN

Attributes

item[RW]

Public Class Methods

disk_or_iso?(device) click to toggle source

Checks if a RbVmomi::VIM::VirtualDevice is a disk or an iso file

# File lib/datastore.rb, line 206
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
exists_one_by_ref_dc_and_type?( ref, dc_ref, vcenter_uuid, type, pool = nil ) click to toggle source
# File lib/datastore.rb, line 225
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
get_image_import_template(params) click to toggle source
# File lib/datastore.rb, line 106
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
get_one_image_ds_by_ref_and_dc( ref, dc_ref, vcenter_uuid, pool = nil ) click to toggle source
# File lib/datastore.rb, line 179
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
new_from_ref(ref, vi_client) click to toggle source
# File lib/datastore.rb, line 98
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

Public Instance Methods

create_directory(directory) click to toggle source
# File lib/datastore.rb, line 303
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
create_virtual_disk(img_name, size, adapter_type, disk_type) click to toggle source
# File lib/datastore.rb, line 280
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
monitor() click to toggle source
# File lib/datastore.rb, line 215
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
obtain_dc() click to toggle source
# File lib/datastore.rb, line 327
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
obtain_fm() click to toggle source
# File lib/datastore.rb, line 319
def obtain_fm
    self['_connection.serviceContent.fileManager']
end
obtain_vdm() click to toggle source
# File lib/datastore.rb, line 323
def obtain_vdm
    self['_connection.serviceContent.virtualDiskManager']
end
to_one(ds_hash, vcenter_uuid, dc_name, dc_ref) click to toggle source
# File lib/datastore.rb, line 252
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
to_one_template(ds_hash, vcenter_uuid, dc_name, dc_ref, type) click to toggle source
# File lib/datastore.rb, line 265
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