Class: VCenterDriver::NetImporter

Inherits:

VcImporter

• Object
• VcImporter
• VCenterDriver::NetImporter

Defined in:

lib/network.rb

Overview

Class NetImporter

Instance Attribute Summary

Attributes inherited from VcImporter

#list

Instance Method Summary

• #add_cluster(cid, eid) ⇒ Object
• #build_ar(opts) ⇒ Object
• #get_list(args = {}) ⇒ Object
• #import(selected, opts = nil) ⇒ Object
• #initialize(one_client, vi_client) ⇒ NetImporter constructor

  A new instance of NetImporter.

• #process_import(indexes, opts = {}, &_block) ⇒ Object
• #remove_default(id) ⇒ Object

Methods inherited from VcImporter

#get_indexes, import_clusters, new_child, #one_str, #output, #retrieve_resources, sanitize, #stdout

Constructor Details

#initialize(one_client, vi_client) ⇒ NetImporter

Returns a new instance of NetImporter.

# File 'lib/network.rb', line 483

def initialize(one_client, vi_client)
    super(one_client, vi_client)
    @one_class = OpenNebula::VirtualNetwork
    @defaults = { :size => '255', :type => 'ether' }
end

Instance Method Details

#add_cluster(cid, eid) ⇒ Object

# File 'lib/network.rb', line 593

def add_cluster(cid, eid)
    one_cluster = @info[:clusters][cid]
    raise 'no cluster defined' unless one_cluster

    one_cluster.addvnet(eid)
end

#build_ar(opts) ⇒ Object

# File 'lib/network.rb', line 612

def build_ar(opts)
    str =  "\nAR=[TYPE=\""
    type = opts[:type].downcase

    case type
    when '4', 'ip4', 'ip'
        str << 'IP4"'
        opts[:ip] = '192.168.1.1' if opts[:ip].empty?
        str << ",IP=\"#{opts[:ip]}\""
    when 'ip6'
        str << 'IP6"'
        if opts[:global_prefix]
            str << ",GLOBAL_PREFIX=\"#{opts[:global_prefix]}\""
        end
        if opts[:ula_prefix]
            str << ",ULA_PREFIX=\"#{opts[:ula_prefix]}\""
        end
    when 'ether', 'e'
        str << 'ETHER"'
    when 'ip6_static'
        str << 'IP6_STATIC"'
        str << ",IP6=\"#{opts[:ip6]}\"" if opts[:ip6]
        if opts[:prefix_length]
            str << ",PREFIX_LENGTH=\"#{opts[:prefix_length]}\""
        end
    end

    str << ",MAC=\"#{opts[:mac]}\"" if opts[:mac]
    str << ",SIZE = \"#{opts[:size]}\"]"

    str
end

#get_list(args = {}) ⇒ Object

# File 'lib/network.rb', line 559

def get_list(args = {})
    dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)

    # OpenNebula's VirtualNetworkPool
    npool = VCenterDriver::VIHelper
            .one_pool(
                OpenNebula::VirtualNetworkPool,
                false
            )
    if npool.respond_to?(:message)
        raise 'Could not get ' \
        "OpenNebula VirtualNetworkPool: #{npool.message}"
    end

    # Get OpenNebula's host pool
    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_networks(
             npool,
             @vi_client.vc_name,
             hpool,
             args
         )
    @list = rs
end

#import(selected, opts = nil) ⇒ Object

# File 'lib/network.rb', line 645

def import(selected, opts = nil)
    opts = @info[selected[:ref]][:opts] if opts.nil?

    net = VCenterDriver::Network
          .new_from_ref(selected[:ref], @vi_client)
    if net
        vid = VCenterDriver::Network
              .retrieve_vlanid(net.item)
    end

    # If type is NSX we need to update values
    if selected[:type] == VCenterDriver::Network::NETWORK_TYPE_NSXV
        host_id = @vi_client.instance_variable_get '@host_id'
        nsx_client = NSXDriver::NSXClient.new_from_id(host_id)
        nsx_net = NSXDriver::VirtualWire
                  .new_from_name(nsx_client, selected[:name])
        selected[:one] << "NSX_ID=\"#{nsx_net.ls_id}\"\n"
        selected[:one] << "NSX_VNI=\"#{nsx_net.ls_vni}\"\n"
        selected[:one] << "NSX_TZ_ID=\"#{nsx_net.tz_id}\"\n"
    end

    if selected[:type] == VCenterDriver::Network::NETWORK_TYPE_NSXT
        host_id = @vi_client.instance_variable_get '@host_id'
        nsx_client = NSXDriver::NSXClient.new_from_id(host_id)
        nsx_net = NSXDriver::OpaqueNetwork
                  .new_from_name(nsx_client, selected[:name])
        selected[:one] << "NSX_ID=\"#{nsx_net.ls_id}\"\n"
        selected[:one] << "NSX_VNI=\"#{nsx_net.ls_vni}\"\n"
        selected[:one] << "NSX_TZ_ID=\"#{nsx_net.tz_id}\"\n"
    end

    if vid
        vlanid = VCenterDriver::Network.vlanid(vid)

        # we have vlan id
        if /\A\d+\z/.match(vlanid)
            selected[:one] << "VCENTER_VLAN_ID=\"#{vlanid}\"\n"
        end
    end

    selected[:one] << build_ar(opts)
    if opts['selected_clusters']
        selected[:clusters][:one_ids] =
            opts['selected_clusters']
            .each
            .map(&:to_i)
    end

    res = { :id => [], :name => selected[:name] }
    create(selected[:one]) do |_one_object, id|
        res[:id] << id
        add_clusters(id, selected[:clusters][:one_ids])
    end

    res
end

#process_import(indexes, opts = {}, &_block) ⇒ Object

# File 'lib/network.rb', line 489

def process_import(indexes, opts = {}, &_block)
    indexes = indexes.gsub(/\s*\,\s*/, ',').strip.split(',')

    dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
    vcenter_instance_name = @vi_client.vc_name
    vcenter_uuid = @vi_client.vim.serviceContent.about.instanceUuid
    hpool = VCenterDriver::VIHelper.one_pool(
        OpenNebula::HostPool,
        false
    )

    one_client = OpenNebula::Client.new
    one_host = OpenNebula::Host.new_with_id(opts[:host], one_client)

    rc = one_host.info
    raise rc.message if OpenNebula.is_error? rc

    # Get all networks in vcenter cluster (one_host)
    vc_cluster_networks = dc_folder.cluster_networks(one_host)

    vc_cluster_networks_map_ref = {}

    # Iterate over vcenter networks
    vc_cluster_networks.each do |vc_cluster_network|
        vc_cluster_networks_map_ref[vc_cluster_network._ref] =
            vc_cluster_network
    end

    indexes.each do |index|
        begin
            @rollback = []
            @info[index] = {}

            vc_cluster_network = vc_cluster_networks_map_ref[index]

            if hpool.respond_to?(:message)
                raise 'Could not get OpenNebula HostPool: ' \
                      "#{hpool.message}"
            end

            params = {}
            params[:vc_network] = vc_cluster_network
            params[:vcenter_instance_name] = vcenter_instance_name
            params[:vcenter_uuid] = vcenter_uuid
            params[:_hpool] = hpool
            params[:one_host] = one_host
            params[:args] = {}

            selected, _networks_type, _hosts_list, _clusters_list =
                dc_folder.process_network(
                    params,
                    {},
                    {},
                    {}
                )

            selected = selected[index]

            # import the object
            opts[index] ||= @defaults
            @info[:success] << import(selected, opts[index])
        rescue StandardError => e
            @info[:error] << { index => e.message }
            @info[index][:e] = e

            apply_rollback
        end
    end
end

#remove_default(id) ⇒ Object

# File 'lib/network.rb', line 600

def remove_default(id)
    cid = 0
    @info[:clusters][cid] ||=
        VCenterDriver::VIHelper
        .one_item(
            OpenNebula::Cluster,
            cid.to_s,
            false
        )
    @info[:clusters][cid].delvnet(id.to_i)
end