class VCenterDriver::Network

Class Network

Constants

NETWORK_TYPE_DPG
NETWORK_TYPE_NSXT
NETWORK_TYPE_NSXV
NETWORK_TYPE_PG
NETWORK_TYPE_UNKNOWN
REQUIRED_ATTRS

Attributes

item[RW]

Public Class Methods

create_one_network(net_config) click to toggle source
# File lib/network.rb, line 273
def self.create_one_network(net_config)
    # mandatory parameters:
    REQUIRED_ATTRS.each do |attr|
        if net_config[attr].nil?
            raise "#{attr} required for importing nics operation!"
        end
    end

    one_vn = VCenterDriver::VIHelper
             .new_one_item(
                 OpenNebula::VirtualNetwork
             )

    done = []
    (0..net_config[:refs].size-1).each do |i|
        cl_id = net_config[:one_ids][i]
        next if cl_id == -1 || done.include?(cl_id)

        if done.empty?
            rc = one_vn.allocate(net_config[:one_object], cl_id.to_i)
            VCenterDriver::VIHelper.check_error(rc, 'create network')
            one_vn.info
        else
            one_cluster = VCenterDriver::VIHelper
                          .one_item(
                              OpenNebula::Cluster,
                              cl_id,
                              false
                          )
            rc = one_cluster.addvnet(one_vn['ID'].to_i)
            VCenterDriver::VIHelper
                .check_error(rc, 'addvnet to cluster')
        end
        done << cl_id
    end

    one_vn
end
generate_name(name, opts = {}) click to toggle source
# File lib/network.rb, line 158
def self.generate_name(name, opts = {})
    vcenter_instance_name = opts[:vcenter_name] || nil
    dc_name               = opts[:dc_name] || nil

    hash_name = "#{name} - [#{vcenter_instance_name} - #{dc_name}]"
    sha256 = Digest::SHA256.new
    network_hash = sha256.hexdigest(hash_name)[0..11]
    "#{name} - [#{vcenter_instance_name} - #{dc_name}]_#{network_hash}"
end
get_network_type(network, network_name) click to toggle source
# File lib/network.rb, line 312
def self.get_network_type(network, network_name)
    case network
    when RbVmomi::VIM::DistributedVirtualPortgroup
        if network_name
           .match(/^vxw-dvs-(.*)-virtualwire-(.*)-sid-(.*)/)
            VCenterDriver::Network::NETWORK_TYPE_NSXV
        else
            VCenterDriver::Network::NETWORK_TYPE_DPG
        end
    when RbVmomi::VIM::OpaqueNetwork
        VCenterDriver::Network::NETWORK_TYPE_NSXT
    when RbVmomi::VIM::Network
        VCenterDriver::Network::NETWORK_TYPE_PG
    else
        VCenterDriver::Network::NETWORK_TYPE_UNKNOWN
    end
end
new(item, vi_client = nil, check = true) click to toggle source
# File lib/network.rb, line 103
def initialize(item, vi_client = nil, check = true)
    if check
        begin
            check_item(item, RbVmomi::VIM::Network)
        rescue StandardError
            check_item(item, RbVmomi::VIM::DistributedVirtualPortgroup)
        end
    end

    @vi_client = vi_client
    @item = item
end
new_from_ref(ref, vi_client) click to toggle source

This is never cached

# File lib/network.rb, line 367
def self.new_from_ref(ref, vi_client)
    new(RbVmomi::VIM::Network.new(vi_client.vim, ref), vi_client)
end
nic?(device) click to toggle source

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

# File lib/network.rb, line 117
def self.nic?(device)
    !device
        .class
        .ancestors
        .index(
            RbVmomi::VIM::VirtualEthernetCard
        ).nil?
end
remove_net_ref(network_id) click to toggle source
# File lib/network.rb, line 352
def self.remove_net_ref(network_id)
    one_vnet = VCenterDriver::VIHelper
               .one_item(
                   OpenNebula::VirtualNetwork,
                   network_id
               )
    one_vnet.info
    one_vnet.delete_element('TEMPLATE/VCENTER_NET_REF')
    one_vnet.delete_element('TEMPLATE/VCENTER_INSTANCE_ID')
    tmp_str = one_vnet.template_str
    one_vnet.update(tmp_str)
    one_vnet.info
end
retrieve_vlanid(network) click to toggle source
# File lib/network.rb, line 139
def self.retrieve_vlanid(network)
    begin
        name = network.name
        id = network
             .host
             .first
             .configManager
             .networkSystem
             .networkConfig
             .portgroup
             .select do |p|
            p.spec.name == name
        end.first.spec.vlanId
    rescue StandardError
        id = -1
    end
    id
end
to_one(opts) click to toggle source
# File lib/network.rb, line 228
def self.to_one(opts)
    template = "NAME=\"#{opts[:network_import_name]}\"\n"\
               "BRIDGE=\"#{opts[:bridge_name]}\"\n"\
               "VN_MAD=\"vcenter\"\n"\
               "VCENTER_PORTGROUP_TYPE=\"#{opts[:network_type]}\"\n"\
               "VCENTER_NET_REF=\"#{opts[:network_ref]}\"\n"\
               "VCENTER_INSTANCE_ID=\"#{opts[:vcenter_uuid]}\"\n"\
               "VCENTER_IMPORTED=\"YES\"\n"

    if opts[:unmanaged] == 'wild'
        template += "VCENTER_FROM_WILD=\"#{opts[:template_id]}\"\n"
    end

    if opts[:template_ref]
        template +=
            "VCENTER_TEMPLATE_REF=\"#{opts[:template_ref]}\"\n"
    end

    if opts[:sw_name]
        template +=
            "VCENTER_SWITCH_NAME=\"#{opts[:sw_name]}\"\n"
    end

    if opts[:nsx_id]
        template +=
            "NSX_ID=\"#{opts[:nsx_id]}\"\n"
    end
    if opts[:nsx_vni]
        template +=
            "NSX_VNI=\"#{opts[:nsx_vni]}\"\n"
    end
    if opts[:nsx_tz_id]
        template +=
            "NSX_TZ_ID=\"#{opts[:nsx_tz_id]}\"\n"
    end

    if opts[:vlanid]
        template +=
            "VCENTER_VLAN_ID=\"#{opts[:vlanid]}\"\n"
    end

    template
end
to_one_template(opts = {}) click to toggle source
# File lib/network.rb, line 168
def self.to_one_template(opts = {})
    one_tmp = {}
    network_name          = opts[:network_name]
    network_ref           = opts[:network_ref]
    network_type          = opts[:network_type]
    sw_name               = opts[:sw_name]

    vcenter_uuid          = opts[:vcenter_uuid]
    cluster_id            = opts[:cluster_id]

    unmanaged             = opts[:unmanaged] || nil
    template_ref          = opts[:template_ref] || nil
    dc_ref                = opts[:dc_ref] || nil
    template_id           = opts[:template_id] || nil

    nsx_id                = opts[:nsx_id] || nil
    nsx_vni               = opts[:nsx_vni] || nil
    nsx_tz_id             = opts[:nsx_tz_id] || nil

    vlanid                = opts[:vlanid] || nil

    bridge_name = network_name
    network_name = network_name.gsub('/', '_')

    network_import_name =
        VCenterDriver::VIHelper
        .one_name(
            OpenNebula::VirtualNetworkPool,
            network_name,
            network_ref+vcenter_uuid
        )

    one_tmp[:name]             = bridge_name
    one_tmp[:import_name]      = network_import_name
    one_tmp[:bridge]           = bridge_name
    one_tmp[:type]             = network_type
    one_tmp[:one_cluster_id]   = cluster_id
    one_tmp[:ref] = network_ref

    opts = {
        :network_import_name    => network_import_name,
        :bridge_name            => bridge_name,
        :network_ref            => network_ref,
        :network_type           => network_type,
        :vcenter_uuid           => vcenter_uuid,
        :unmanaged              => unmanaged,
        :template_ref           => template_ref,
        :dc_ref                 => dc_ref,
        :template_id            => template_id,
        :sw_name                => sw_name,
        :nsx_id                 => nsx_id,
        :nsx_vni                => nsx_vni,
        :nsx_tz_id              => nsx_tz_id,
        :vlanid                 => vlanid
    }

    one_tmp[:one] = to_one(opts)
    one_tmp
end
virtual_switch(vc_pg) click to toggle source

Get vSwitch of Standard PortGroup If there is differents vSwitches returns the first.

# File lib/network.rb, line 332
def self.virtual_switch(vc_pg)
    vswitch = []
    vc_hosts = vc_pg.host
    vc_hosts.each do |vc_host|
        host_pgs = vc_host
                   .configManager
                   .networkSystem
                   .networkInfo
                   .portgroup
        host_pgs.each do |pg|
            if vc_pg.name == pg.spec.name
                vswitch << pg.spec.vswitchName
            end
        end
    end
    vswitch.uniq!
    vswitch << 'Invalid configuration' if vswitch.length > 1
    vswitch.join(' / ')
end
vlanid(vid) click to toggle source
# File lib/network.rb, line 126
def self.vlanid(vid)
    case vid
    when -1
        'error'
    when 0
        'disabled'
    when 4095
        'VGT'
    else
        vid.to_s
    end
end