opennebula 5.12.6 → 5.13.90.pre

data/lib/network.rb

@@ -0,0 +1,708 @@
+# -------------------------------------------------------------------------- #
+# 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.                                             #
+#--------------------------------------------------------------------------- #
+
+require 'digest'
+
+##############################################################################
+# Module VCenterDriver
+##############################################################################
+module VCenterDriver
+
+    ##########################################################################
+    # Class NetworkFolder
+    ##########################################################################
+    class NetworkFolder
+
+        attr_accessor :item, :items
+
+        def initialize(item)
+            @item = item
+            @items = {}
+        end
+
+        ######################################################################
+        # Builds a hash with Network-Ref / Network to be used as a cache
+        # @return [Hash] in the form
+        #   { ds_ref [Symbol] => Network object }
+        ######################################################################
+        def fetch!
+            VIClient.get_entities(@item, 'Network').each do |item|
+                item_name = item._ref
+                @items[item_name.to_sym] = PortGroup.new(item)
+            end
+
+            VIClient
+                .get_entities(
+                    @item,
+                    'DistributedVirtualPortgroup'
+                ).each do |item|
+                item_name = item._ref
+                @items[item_name.to_sym] = DistributedPortGroup.new(item)
+            end
+
+            VIClient
+                .get_entities(
+                    @item,
+                    'VmwareDistributedVirtualSwitch'
+                ).each do |item|
+                item_name = item._ref
+                @items[item_name.to_sym] = DistributedVirtualSwitch.new(item)
+            end
+
+            VIClient.get_entities(@item, 'OpaqueNetwork').each do |item|
+                item_name = item._ref
+                @items[item_name.to_sym] = OpaqueNetwork.new(item)
+            end
+        end
+
+        ########################################################################
+        # Returns a Network. Uses the cache if available.
+        # @param ref [Symbol] the vcenter ref
+        # @return Network
+        ########################################################################
+        def get(ref)
+            if !@items[ref.to_sym]
+                rbvmomi_net = RbVmomi::VIM::Network.new(@item._connection, ref)
+                @items[ref.to_sym] = Network.new(rbvmomi_net)
+            end
+
+            @items[ref.to_sym]
+        end
+
+    end
+    # class NetworkFolder
+
+    ##########################################################################
+    # Class Network
+    ##########################################################################
+    class Network
+
+        attr_accessor :item
+
+        include Memoize
+
+        NETWORK_TYPE_PG = 'Port Group'
+        NETWORK_TYPE_DPG = 'Distributed Port Group'
+        NETWORK_TYPE_NSXV = 'NSX-V' # "Virtual Wire"
+        NETWORK_TYPE_NSXT = 'Opaque Network'
+        NETWORK_TYPE_UNKNOWN = 'Unknown Network'
+
+        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
+
+        #  Checks if a RbVmomi::VIM::VirtualDevice is a network interface
+        def self.nic?(device)
+            !device
+                .class
+                .ancestors
+                .index(
+                    RbVmomi::VIM::VirtualEthernetCard
+                ).nil?
+        end
+
+        def self.vlanid(vid)
+            case vid
+            when -1
+                'error'
+            when 0
+                'disabled'
+            when 4095
+                'VGT'
+            else
+                vid.to_s
+            end
+        end
+
+        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
+
+        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
+
+        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
+
+        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
+
+        REQUIRED_ATTRS = [:refs, :one_ids, :one_object]
+        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
+
+        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
+
+        # Get vSwitch of Standard PortGroup
+        # If there is differents vSwitches returns the first.
+        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
+
+        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
+
+        # This is never cached
+        def self.new_from_ref(ref, vi_client)
+            new(RbVmomi::VIM::Network.new(vi_client.vim, ref), vi_client)
+        end
+
+    end
+    # class Network
+
+    ##########################################################################
+    # Class PortGroup
+    ##########################################################################
+    class PortGroup < Network
+
+        def initialize(item, vi_client = nil, _check = true)
+            check_item(item, RbVmomi::VIM::Network)
+
+            super(item, vi_client, false)
+        end
+
+        def clusters
+            net_clusters = {}
+            host_members =@item['host']
+            host_members.each do |h|
+                if !net_clusters.key?(h.parent._ref.to_s)
+                    net_clusters[h.parent._ref.to_s] = h.parent.name.to_s
+                end
+            end
+            net_clusters
+        end
+
+        def network_type
+            VCenterDriver::Network::NETWORK_TYPE_PG
+        end
+
+    end
+    # class PortGroup
+
+    ##########################################################################
+    # Class DistributedPortGroup
+    ##########################################################################
+    class DistributedPortGroup < Network
+
+        def initialize(item, vi_client = nil, _check = true)
+            check_item(item, RbVmomi::VIM::DistributedVirtualPortgroup)
+
+            super(item, vi_client, false)
+        end
+
+        def clusters
+            net_clusters = {}
+            # should have to work
+            # host_members =@item['host']
+            host_members =
+                self['config.distributedVirtualSwitch.summary.hostMember']
+            host_members.each do |h|
+                if !net_clusters.key?(h.parent._ref.to_s)
+                    net_clusters[h.parent._ref.to_s] = h.parent.name.to_s
+                end
+            end
+            net_clusters
+        end
+
+        def network_type
+            VCenterDriver::Network::NETWORK_TYPE_DPG
+        end
+
+    end
+    # class DistributedPortGroup
+
+    ##########################################################################
+    # Class OpaqueNetwork
+    ##########################################################################
+    class OpaqueNetwork < Network
+
+        def initialize(item, vi_client = nil, _check = true)
+            check_item(item, RbVmomi::VIM::OpaqueNetwork)
+
+            super(item, vi_client, false)
+        end
+
+        def clusters
+            net_clusters = {}
+            host_members =@item['host']
+            host_members.each do |h|
+                if !net_clusters.key?(h.parent._ref.to_s)
+                    net_clusters[h.parent._ref.to_s] = h.parent.name.to_s
+                end
+            end
+            net_clusters
+        end
+
+        def network_type
+            VCenterDriver::Network::NETWORK_TYPE_NSXT
+        end
+
+    end
+    # class OpaqueNetwork
+
+    ##########################################################################
+    # Class DistributedVirtualSwitch
+    ##########################################################################
+    class DistributedVirtualSwitch < Network
+
+        def initialize(item, vi_client = nil, _check = true)
+            check_item(item, RbVmomi::VIM::VmwareDistributedVirtualSwitch)
+
+            super(item, vi_client, false)
+        end
+
+    end
+    # class DistributedVirtualSwitch
+
+    ##########################################################################
+    # Class NetImporter
+    ##########################################################################
+    class NetImporter < VCenterDriver::VcImporter
+
+        def initialize(one_client, vi_client)
+            super(one_client, vi_client)
+            @one_class = OpenNebula::VirtualNetwork
+            @defaults = { :size => '255', :type => 'ether' }
+        end
+
+        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
+
+                    opts = {}
+
+                    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] = opts
+
+                    selected = dc_folder.process_network(params)
+
+                    selected = selected[index]
+
+                    if block_given?
+                        @info[index][:opts] = block.call(selected)
+                    elsif opts[index]
+                        @info[index][:opts] = opts[index]
+                    else
+                        @info[index][:opts] = defaults
+                    end
+
+                    # import the object
+                    @info[:success] << import(selected)
+                rescue StandardError => e
+                    @info[:error] << { index => e.message }
+                    @info[index][:e] = e
+
+                    apply_rollback
+                end
+            end
+        end
+
+        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
+
+        def add_cluster(cid, eid)
+            one_cluster = @info[:clusters][cid]
+            raise 'no cluster defined' unless one_cluster
+
+            one_cluster.addvnet(eid)
+        end
+
+        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
+
+        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
+
+        def import(selected)
+            opts = @info[selected[:ref]][:opts]
+
+            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
+
+    end
+
+end
+# module VCenterDriver