F #3930: NSX Security Groups (#4255)

* DFW - Initial function definition
* Section functions working on NSX-T
* Add revision to create rules
* Add check error to create_rule
* Fix error on delete_rule method
* Added NSX-V support
* Clear OpenNebula rules function

Co-authored-by: Tino Vazquez <tinova@opennebula.org>
This commit is contained in:
Angel Luis Moya GonzalezandTino Vazquez authored and GitHub committed 2020-05-07 15:05:20 +02:00
1 parent a224d86373
commit e3a2a9ee71
27 files changed
+2188 -244

No files matched your search

+12 -2
View File
@@ -991,7 +991,16 @@ VMM_EXEC_LIB_NSX_FILES="src/vmm_mad/remotes/lib/nsx_driver/logical_switch.rb \
src/vmm_mad/remotes/lib/nsx_driver/transport_zone.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxt_tz.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxv_tz.rb \
src/vmm_mad/remotes/lib/nsx_driver/virtual_wire.rb"
src/vmm_mad/remotes/lib/nsx_driver/virtual_wire.rb \
src/vmm_mad/remotes/lib/nsx_driver/distributed_firewall.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxt_dfw.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxv_dfw.rb \
src/vmm_mad/remotes/lib/nsx_driver/logical_port.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxt_logical_port.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxv_logical_port.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsx_rule.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxt_rule.rb \
src/vmm_mad/remotes/lib/nsx_driver/nsxv_rule.rb"
#-------------------------------------------------------------------------------
# VMM SH Driver LXD scripts, to be installed under $REMOTES_LOCATION/vmm/lxd
@@ -1531,7 +1540,8 @@ NETWORK_OVSWITCH_VXLAN_FILES="src/vnm_mad/remotes/ovswitch_vxlan/clean \
NETWORK_VCENTER_FILES="src/vnm_mad/remotes/vcenter/pre \
src/vnm_mad/remotes/vcenter/post \
src/vnm_mad/remotes/vcenter/clean"
src/vnm_mad/remotes/vcenter/clean \
src/vnm_mad/remotes/vcenter/update_sg"
NETWORK_ALIAS_SDNAT_FILES="src/vnm_mad/remotes/alias_sdnat/AliasSDNAT.rb \
src/vnm_mad/remotes/alias_sdnat/clean \
+2 -2
View File
@@ -22,8 +22,8 @@ else
MAD_LOCATION=$ONE_LOCATION/lib/mads
fi
LOCAL_ACTIONS="deploy,shutdown,reboot,cancel,save,restore,migrate,poll,pre"
LOCAL_ACTIONS="${LOCAL_ACTIONS},post,clean"
LOCAL_ACTIONS="deploy,shutdown,reboot,cancel,save,restore,migrate,poll"
LOCAL_ACTIONS="${LOCAL_ACTIONS},pre,post,clean,update_sg"
LOCAL_ACTIONS="${LOCAL_ACTIONS},snapshotcreate,snapshotrevert,snapshotdelete"
LOCAL_ACTIONS="${LOCAL_ACTIONS},attach_nic,detach_nic,reset"
LOCAL_ACTIONS="${LOCAL_ACTIONS},prereconfigure,reconfigure"
@@ -0,0 +1,285 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
ONE_LOCATION = ENV['ONE_LOCATION'] unless defined?(ONE_LOCATION)
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby' \
unless defined?(RUBY_LIB_LOCATION)
GEMS_LOCATION = '/usr/share/one/gems' \
unless defined?(GEMS_LOCATION)
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby' \
unless defined?(RUBY_LIB_LOCATION)
GEMS_LOCATION = ONE_LOCATION + '/share/gems' \
unless defined?(GEMS_LOCATION)
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
require 'nsx_rule'
# Class DistributedFirewall
# Naming convention for rules names:
# "<sg_id>-<sg_name>-<vm_id>-<vm_deploy_id>-<nic_id>"
# <sg_id> : Security Group ID
# <sg_name> : Security Group name
# <vm_id> : Virtual Machine ID
# <vm_deploy_id> : Vmware virtual machine reference ( vm-XXX )
# <nic_id> : NIC ID in the virtual machine
class DistributedFirewall < NSXComponent
include NSXDriver::NSXRule
# ATTRIBUTES
attr_reader :one_section_name
# CONSTRUCTOR
def initialize(nsx_client)
super(nsx_client)
end
def self.new_child(nsx_client)
case nsx_client
when NSXTClient
NSXTdfw.new(nsx_client)
when NSXVClient
NSXVdfw.new(nsx_client)
else
error_msg = "Unknown object type: #{nsx_client}"
error = NSXError::UnknownObject.new(error_msg)
raise error
end
end
# Sections
# Creates OpenNebula section if not exists and returns
# its section_id. Returns its section_id if OpenNebula
# section already exists
def init_section; end
# Get all sections
def sections; end
# Get section by id
def section_by_id(section_id); end
# Get section by name
def section_by_name(section_name); end
# Create new section
def create_section(section_name); end
# Delete section
def delete_section(section_id); end
# Rules
# Get all rules
def rules; end
# Get rule by id
def rule_by_id; end
# Get rule by name
def rules_by_name; end
# Create new rule
def create_rule; end
# Update rule
def update_rule; end
# Delete rule
def delete_rule; end
def extract_nic_data(nic, nsx_client, vm)
# Network attributes
nic_id = nic.xpath('NIC_ID').text
nic_name = nil
nic_lp = nil
network_id = nic.xpath('NETWORK_ID').text
network_name = nic.xpath('NETWORK').text
network_vcref = nic.xpath('VCENTER_NET_REF').text
network_pgtype = nic.xpath('VCENTER_PORTGROUP_TYPE').text
network_mac = nic.xpath('MAC').text
# Virtual Machine devices
vm_devices = vm.item.config.hardware.device
vm_devices.each do |device|
next unless vm.is_nic?(device)
next if device.macAddress != network_mac
device_label = device.deviceInfo.label
nic_name = "#{vm.item.name}-#{nic_id}-#{device_label}"
case network_pgtype
when NSXConstants::NSXT_LS_TYPE
lpid = device.externalId
nic_lp = LogicalPort.new_child(nsx_client, lpid)
raise "Logical port id: #{lpid} not found" unless nic_lp
when NSXConstants::NSXV_LS_TYPE
# lpid is vm instanceUuid.sufix
# sufix is device number but removing first number
suffix = device.key.to_s[1..-1]
lpid = "#{vm.item.config.instanceUuid}.#{suffix}"
nic_lp = lpid
else
error_msg = "Network type is: #{network_pgtype} \
and should be \
#{NSXConstants::NSXT_LS_TYPE} \
or #{NSXConstants::NSXV_LS_TYPE}"
error = NSXError::UnknownObject.new(error_msg)
raise error
end
break
end
nic_data = {
:id => nic_id,
:name => nic_name,
:network_name => network_name,
:network_id => network_id,
:network_vcref => network_vcref,
:lp => nic_lp
}
nic_data
end
# Create OpenNebula fw rules for an instance (given a template)
def create_rules(deploy_id, template, only_attached)
template_xml = Nokogiri::XML(template)
# OpenNebula host
host_name = template_xml
.xpath('//HISTORY_RECORDS/HISTORY[last()]/HOSTNAME')
.text
one_host = VCenterDriver::VIHelper
.find_by_name(OpenNebula::HostPool, host_name)
rc = one_host.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
host_id = one_host['ID']
# OpenNebula VM
one_vm = VCenterDriver::VIHelper
.one_item(OpenNebula::VirtualMachine, deploy_id)
vm_data = {
:id => template_xml.xpath('/VM/ID').text,
:deploy_id => deploy_id
}
# vCenter VirtualMachine
vi_client = VCenterDriver::VIClient.new_from_host(host_id)
vm = VCenterDriver::VirtualMachine
.new_one(vi_client, deploy_id, one_vm)
# NSX Objects needed
ls = LogicalSwitch.new(@nsx_client)
# Search NSX Nics
# First try to search only new attached NSX Nics
nsx_nics = ls.nsx_nics(template_xml, only_attached)
# If there is no NSX Nics
return if nsx_nics.empty?
# Create rules for each NSX Nic
nsx_nics.each do |nic|
# Extract NIC data
nic_data = extract_nic_data(nic, @nsx_client, vm)
# Get all Security Groups belonging to each NIC.
sec_groups = nic.xpath('SECURITY_GROUPS').text.split(',')
sec_groups.each do |sec_group|
sg_rules_array = []
# Get all rules belonging to this Security Group.
xp = "//SECURITY_GROUP_RULE[SECURITY_GROUP_ID=#{sec_group}]"
sg_rules = template_xml.xpath(xp)
sg_rules.each do |sg_rule|
# Create rules spec
rule_data = extract_rule_data(sg_rule)
rule_spec = rule_spec(rule_data,
vm_data,
nic_data,
@nsx_client)
sg_rules_array.push(rule_spec)
end
# Create NSX rules
sg_rules_array.each do |sg_spec|
create_rule(sg_spec)
end
end
end
end
def clear_all_rules(template)
template_xml = Nokogiri::XML(template)
vm_id = template_xml.xpath('/VM/ID').text
vm_deploy_id = template_xml.xpath('/VM/DEPLOY_ID').text
regex = "-#{vm_id}-#{vm_deploy_id}-"
rules = rules_by_regex(regex, @one_section_id)
rules.each do |rule|
delete_rule(rule['id'], @one_section_id) if rule
end
end
# Remove OpenNebula created fw rules for an instance (given a template)
def clear_rules(template, only_detached)
template_xml = Nokogiri::XML(template)
# OpenNebula Instance IDs
vm_id = template_xml.xpath('/VM/ID').text
vm_deploy_id = template_xml.xpath('/VM/DEPLOY_ID').text
# Search NSX Nics
ls = LogicalSwitch.new(@nsx_client)
# First try to search only new attached NSX Nics
nsx_nics = ls.nsx_nics(template_xml, only_detached)
# If there is no NSX Nics
return if nsx_nics.empty?
nsx_nics.each do |nic|
nic_id = nic.xpath('NIC_ID').text
# network_id = nic.xpath('NETWORK_ID').text
sec_groups = nic.xpath('SECURITY_GROUPS').text.split(',')
sec_groups.each do |sec_group|
# Get Security Group ID and NAME
xp = "//SECURITY_GROUP_RULE[SECURITY_GROUP_ID=#{sec_group}]"
sg_id = template_xml.xpath(xp)[0]
.xpath('SECURITY_GROUP_ID').text
sg_name = template_xml.xpath(xp)[0]
.xpath('SECURITY_GROUP_NAME').text
rule_name = "#{sg_id}-#{sg_name}-#{vm_id}"
rule_name << "-#{vm_deploy_id}-#{nic_id}"
rules = rules_by_name(rule_name, @one_section_id)
rules.each do |rule|
delete_rule(rule['id'], @one_section_id) if rule
end
end
end
end
end
end
@@ -0,0 +1,56 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
# Class Logical Switch
class LogicalPort < NSXComponent
# ATTRIBUTES
# CONSTRUCTOR
def initialize(nsx_client)
super(nsx_client)
end
def self.new_child(nsx_client, id = nil)
case nsx_client.nsx_type.upcase
when NSXConstants::NSXT
NSXTLogicalPort.new(nsx_client, id)
when NSXConstants::NSXV
NSXVLogicalPort.new(nsx_client, id)
else
error_msg = "Unknown object type: #{type}"
error = NSXError::UnknownObject.new(error_msg)
raise error
end
end
# Check if logical port exists
def lp?; end
# Get logical port id
def lp_id; end
# Get logical port display name
def lp_name; end
# Get resource type
def lp_type; end
end
end
@@ -16,7 +16,7 @@
module NSXDriver
# Class Logical Switch
class LogicalSwitch < NSXDriver::NSXComponent
class LogicalSwitch < NSXComponent
# ATTRIBUTES
attr_reader :ls_id
@@ -51,6 +51,33 @@ module NSXDriver
# Update a logical switch
def update_logical_switch; end
# Return nsx nics of type NSX-V and NSX-T
# If only_new_attached = true --> Only returns new attached nsx nics
def nsx_nics(template_xml, only_new_attached = true)
if only_new_attached == true
nics = template_xml.xpath('//TEMPLATE/NIC[ATTACH="YES"]')
else
nics = template_xml.xpath('//TEMPLATE/NIC')
end
nics_array = []
nics.each do |nic|
network_id = nic.xpath('NETWORK_ID').text
# Check Networks exists
one_vnet = VCenterDriver::VIHelper
.one_item(OpenNebula::VirtualNetwork, network_id)
rc = one_vnet.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
pg_type = one_vnet['TEMPLATE/VCENTER_PORTGROUP_TYPE']
nics_array << nic if [NSXConstants::NSXV_LS_TYPE,
NSXConstants::NSXT_LS_TYPE]
.include?(pg_type)
end
nics_array
end
end
end
@@ -60,13 +60,13 @@ module NSXDriver
def self.new_child(nsxmgr, nsx_user, nsx_password, type)
case type.upcase
when NSXDriver::NSXConstants::NSXT
NSXDriver::NSXTClient.new(nsxmgr, nsx_user, nsx_password)
when NSXDriver::NSXConstants::NSXV
NSXDriver::NSXVClient.new(nsxmgr, nsx_user, nsx_password)
when NSXConstants::NSXT
NSXTClient.new(nsxmgr, nsx_user, nsx_password)
when NSXConstants::NSXV
NSXVClient.new(nsxmgr, nsx_user, nsx_password)
else
error_msg = "Unknown object type: #{type}"
error = NSXDriver::NSXError::UnknownObject.new(error_msg)
error = NSXError::UnknownObject.new(error_msg)
raise error
end
end
@@ -83,7 +83,7 @@ module NSXDriver
nsxmgr = host['TEMPLATE/NSX_MANAGER']
nsx_user = host['TEMPLATE/NSX_USER']
nsx_password = NSXDriver::NSXClient
nsx_password = NSXClient
.nsx_pass(host['TEMPLATE/NSX_PASSWORD'])
nsx_type = host['TEMPLATE/NSX_TYPE']
@@ -92,11 +92,20 @@ module NSXDriver
# METHODS
# Return response if match with responses codes, If response not match
# with expected responses codes then raise an IncorrectResponseCodeError
def check_response(response, codes_array)
codes_array.each do |code|
return true if response.code.to_i == code
unless response.nil?
return response if codes_array.include?(response.code.to_i)
response_json = JSON.parse(response.body)
nsx_error = "\nNSX error code: " \
"#{response_json['errorCode']}, " \
"\nNSX error details: " \
"#{response_json['details']}"
raise NSXError::IncorrectResponseCodeError, nsx_error
end
false
raise NSXError::IncorrectResponseCodeError, nsx_error
end
def self.nsx_pass(nsx_pass_enc)
@@ -114,17 +123,23 @@ module NSXDriver
end
# Return: respose.body
def get(url); end
def get(url, aditional_headers = []); end
# Return: response
def get_full_response(url, aditional_headers = []); end
# Return: id of the created object
def post(url, data); end
def post(url, data, aditional_headers = []); end
def put(url, data); end
def put(url, data, aditional_headers = []); end
def delete(url); end
def get_token(url); end
# Prepare headers
def add_headers(aditional_headers = []); end
end
end
@@ -54,6 +54,7 @@ module NSXDriver
NSXT_TZS = NSXT_BASE + '/transport-zones'
# VirtualWire
NSXV_AUTH = NSXV_BASE + '/services/auth/token'
NSXV_LS_TYPE = 'NSX-V'
NSXV_LS_NAME_XPATH = '//virtualWire/name'
NSXV_LS_VNI_XPATH = '//virtualWire/vdnId'
NSXV_LS_BACKING_XPATH = '//virtualWire/vdsContextWithBacking' \
@@ -66,6 +67,7 @@ module NSXDriver
NSXV_TZ_XPATH = '//virtualWire/vdnScopeId'
# OpaqueNetwork
NSXT_AUTH = NSXT_BASE + '/aaa/registration-token'
NSXT_LS_TYPE = 'Opaque Network'
NSXT_LS_SECTION = NSXT_BASE + '/logical-switches/'
# DFW
ONE_SECTION_NAME = 'OpenNebula'
@@ -75,6 +77,43 @@ module NSXDriver
NSXV_DFW_SECTIONS = '/layer3sections'
NSXV_DFW_SECTION_XPATH = '//section'
NSXV_DFW_RULE_XPATH = '//rule'
# RULE
NSXT_RULE_BASE = NSXT_BASE + '/firewall/rules'
NSXT_RULE_PROTOCOL = {
'TCP' => {
:service => {
:l4_protocol => 'TCP',
:source_ports => [],
:destination_ports => [],
:resource_type => 'L4PortSetNSService'
}
},
'UDP' => {
:service => {
:l4_protocol => 'UDP',
:source_ports => [],
:destination_ports => [],
:resource_type => 'L4PortSetNSService'
}
},
'ICMP' => {
:service => {
:protocol => 'ICMPv4',
:resource_type => 'ICMPTypeNSService'
}
},
'ICMPv6' => {
:service => {
:protocol => 'ICMPv6',
:resource_type => 'ICMPTypeNSService'
}
}
}
NSXV_RULE_BASE = 'xxx'
NSX_RULE_IPSEC_PORTS = %w[500 4500]
# Logical Ports
NSXT_LP_BASE = NSXT_BASE + '/logical-ports/'
NSXV_LP_BASE = ''
# Messages
MSG_INCOMPLETE_REQ = 'Incomplete request, NSX_MANAGER, NSX_USER, \
NSX_PASSWORD and NSX_TYPE are needed'
@@ -62,6 +62,16 @@ module NSXDriver
end
# Class DeleteError
class MissingParameter < NSXError
def initialize(parameter)
msg = "Missing NSX parameter #{parameter}"
super(msg)
end
end
end
end
@@ -0,0 +1,191 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 'ipaddr'
# Module NSXDriver
module NSXDriver
ONE_LOCATION = ENV['ONE_LOCATION'] unless defined?(ONE_LOCATION)
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby' \
unless defined?(RUBY_LIB_LOCATION)
GEMS_LOCATION = '/usr/share/one/gems' \
unless defined?(GEMS_LOCATION)
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby' \
unless defined?(RUBY_LIB_LOCATION)
GEMS_LOCATION = ONE_LOCATION + '/share/gems' \
unless defined?(GEMS_LOCATION)
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
require 'nsxt_rule'
require 'nsxv_rule'
# Class Logical Switch
module NSXRule
include NSXTRule
include NSXVRule
def to_nets(ip_start, size)
nets = []
ipaddr = IPAddr.new ip_start
ip_i = ipaddr.to_i
if ipaddr.ipv4?
ip_length = 32
elsif ipaddr.ipv6?
ip_length = 128
else
return
end
# Find the largest address block (look for the first 1-bit)
lblock = 0
lblock += 1 while ip_i[lblock] == 0 && lblock < ip_length
# Allocate whole blocks till the size fits
while size >= 2**lblock
nets << "#{IPAddr.new(ip_i, ipaddr.family)}" \
"/#{ip_length-lblock}"
ip_i += 2**lblock
size -= 2**lblock
lblock += 1 while ip_i[lblock] == 0 && lblock < ip_length
end
# Fit remaining address blocks
ip_length.downto(0) do |i|
next if size[i] == 0
nets << "#{IPAddr.new(ip_i, ipaddr.family)}/#{ip_length-i}"
ip_i += 2**i
end
nets
end
# Adapt port from ["22, 443"] to '22, 443'
# Adapt port from ["22", "443"] to '22, 443'
def parse_ports(rule_ports)
unless rule_ports.empty?
rule_ports = rule_ports.join(',')
end
rule_ports
end
def extract_vnet_data(vnet_id)
if vnet_id == ''
return {
:nsxid => '',
:name => ''
}
end
# Create client to communicate with OpenNebula
one_client = OpenNebula::Client.new
# Get the network XML from OpenNebula
# This is potentially different from the Netowrk Template
# provided as the API call argument
one_vnet = OpenNebula::VirtualNetwork.new_with_id(vnet_id,
one_client)
rc = one_vnet.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise CreateNetworkError, err_msg
end
vnet_data = {
:nsxid => one_vnet['TEMPLATE/NSX_ID'],
:name => one_vnet['NAME']
}
vnet_data
end
def extract_rule_data(xml_rule)
sg_id = xml_rule.xpath('SECURITY_GROUP_ID').text
sg_name = xml_rule.xpath('SECURITY_GROUP_NAME').text
in_out = xml_rule.xpath('RULE_TYPE').text.upcase
in_out == 'INBOUND' ? sg_direction = 'IN' : sg_direction = 'OUT'
# Protocol: TCP, UDP, ICMP...
sg_protocol = xml_rule.xpath('PROTOCOL').text
if sg_protocol == 'ICMP'
sg_icmp_type = xml_rule.xpath('ICMP_TYPE').text
end
# OpenNebula network ID
sg_network_id = xml_rule.xpath('NETWORK_ID').text
vnet_data = extract_vnet_data(sg_network_id)
# ip / netmask
sg_ip = xml_rule.xpath('IP').text
sg_ipsize = xml_rule.xpath('SIZE').text
sg_subnets = []
if sg_ip != '' && sg_ipsize != ''
sg_subnets = to_nets(sg_ip, sg_ipsize.to_i)
end
# Ports
sg_ports = ''
sg_range_port = xml_rule.xpath('RANGE').text
if sg_range_port
if sg_range_port.index(':')
sg_port_from = sg_range_port[0..sg_range_port.index(':')-1]
sg_port_to = sg_range_port[sg_range_port.index(':')+1,
sg_range_port.length]
sg_ports = "#{sg_port_from}-#{sg_port_to}"
else
sg_ports = sg_range_port
end
end
# Create hash with data
rule_data = {
:id => sg_id,
:name => sg_name,
:direction => sg_direction,
:protocol => sg_protocol,
:icmp_type => sg_icmp_type,
:network_id => sg_network_id,
:network_name => vnet_data[:name],
:network_nsxid => vnet_data[:nsxid],
:subnets => sg_subnets,
:ports => sg_ports.split(',')
}
rule_data
end
def rule_spec(rule, vm_data, nic_data, nsx_client)
case nsx_client.nsx_type
when NSXDriver::NSXConstants::NSXT
nsxt_rule_spec(rule, vm_data, nic_data)
when NSXDriver::NSXConstants::NSXV
nsxv_rule_spec(rule, vm_data, nic_data)
else
raise "Unsupported NSX type: #{nsx_type}"
end
end
end
end
@@ -37,7 +37,7 @@ module NSXDriver
$LOAD_PATH << RUBY_LIB_LOCATION
# Class NSXTClient
class NSXTClient < NSXDriver::NSXClient
class NSXTClient < NSXClient
# ATTIBUTES
attr_accessor :nsxmgr
@@ -48,133 +48,122 @@ module NSXDriver
# CONSTRUCTORS
def initialize(nsxmgr, nsx_user, nsx_password)
super(nsxmgr, nsx_user, nsx_password)
@nsx_type = NSXDriver::NSXConstants::NSXT
@nsx_type = NSXConstants::NSXT
end
# Prepare headers
def add_headers(aditional_headers = [])
headers = NSXConstants::HEADER_JSON.clone
unless aditional_headers.empty?
aditional_headers.each do |header|
headers[header.keys[0]] = header.values[0]
end
end
headers
end
# METHODS
def get(url)
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Get.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
request.basic_auth(@nsx_user, @nsx_password)
begin
response = Net::HTTP
.start(uri.host,
uri.port,
:use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE)\
do |https|
https.request(request)
end
rescue StandardError => e
raise e
def get(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
return JSON.parse(response.body) \
if check_response(response, [NSXDriver::NSXConstants::CODE_OK])
uri = URI.parse(@nsxmgr + url)
headers = add_headers(aditional_headers)
request = Net::HTTP::Get.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
JSON.parse(response.body)
end
def get_full_response(url)
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Get.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
request.basic_auth(@nsx_user, @nsx_password)
begin
response = Net::HTTP
.start(uri.host,
uri.port,
:use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE)\
do |https|
https.request(request)
end
rescue StandardError => e
raise e
def get_full_response(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
return response \
if check_response(response, [NSXDriver::NSXConstants::CODE_OK])
uri = URI.parse(@nsxmgr + url)
headers = add_headers(aditional_headers)
request = Net::HTTP::Get.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, valid_codes)
end
# Return: id of the created object
def post(url, data)
def post(url, data, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Post.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
headers = add_headers(aditional_headers)
request = Net::HTTP::Post.new(uri.request_uri, headers)
request.body = data
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response_json = JSON.parse(response.body)
# If response is different as expected raise the message
unless check_response(response,
[NSXDriver::NSXConstants::CODE_CREATED])
error_msg = "\nNSX error code: " \
"#{response_json['errorCode']}, " \
"\nNSX error details: " \
"#{response_json['details']}"
error = NSXDriver::NSXError::IncorrectResponseCodeError
.new(error_msg)
raise error
end
response_json['id']
end
def put(url, data)
def put(url, data, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Put.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
headers = add_headers(aditional_headers)
request = Net::HTTP::Put.new(uri.request_uri, headers)
request.body = data
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response_json = JSON.parse(response.body)
# If response is different as expected raise the message
unless check_response(response,
[NSXDriver::NSXConstants::CODE_CREATED])
error_msg = "\nNSX error code: " \
"#{response_json['errorCode']}, " \
"\nNSX error details: " \
"#{response_json['details']}"
error = NSXDriver::NSXError::IncorrectResponseCodeError
.new(error_msg)
raise error
end
response_json['id']
end
def delete(url)
def delete(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Delete
.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
headers = add_headers(aditional_headers)
request = Net::HTTP::Delete.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, [NSXDriver::NSXConstants::CODE_OK])
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, valid_codes)
end
def get_token(url)
def get_token(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Post.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_JSON)
headers = add_headers(aditional_headers)
request = Net::HTTP::Post.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
return unless check_response(response,
[NSXDriver::NSXConstants::CODE_OK])
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response.body
end
@@ -0,0 +1,200 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
# Class Logical Switch
class NSXTdfw < DistributedFirewall
# ATTRIBUTES
attr_reader :one_section_id
# CONSTRUCTOR
# Creates OpenNebula section if not exists
def initialize(nsx_client)
super(nsx_client)
# Construct base URLs
@base_url = NSXConstants::NSXT_DFW_BASE
@url_sections = @base_url + \
NSXConstants::NSXT_DFW_SECTIONS
@one_section_id = init_section
end
# Sections
# Creates OpenNebula section if not exists and returns
# its section_id. Returns its section_id if OpenNebula
# section already exists
def init_section
one_section = section_by_name(
NSXConstants::ONE_SECTION_NAME
)
one_section ||= create_section(
NSXConstants::ONE_SECTION_NAME
)
return one_section['id'] if one_section
end
# Get all sections
# Params:
# - None
# Return
# - nil | sections
def sections
result = @nsx_client.get(@url_sections)
result['results']
end
# Get section by id
# Params:
# - section_id: [String] ID of the section or @one_section_id
# Return
# - nil | section
def section_by_id(section_id = @one_section_id)
url = @url_sections + '/' + section_id
@nsx_client.get(url)
end
# Get section by name
# Params:
# - section_name: Name of the section
# Return
# - nil | section
def section_by_name(section_name)
result = nil
all_sections = sections
return result unless all_sections
all_sections.each do |section|
result = section if section['display_name'] == section_name
end
result
end
# Create new section and return the section
def create_section(section_name)
section_spec = %(
{
"display_name": "#{section_name}",
"section_type": "LAYER3",
"stateful": true
}
)
section_id = @nsx_client.post(@url_sections, section_spec)
result = section_by_id(section_id)
raise 'Section was not created in DFW' unless result
result
end
# Delete section
# Params:
# - section_id: [String] ID of the section or @one_section_id
def delete_section(section_id = @one_section_id)
url = @url_sections + '/' + section_id
@nsx_client.delete(url)
end
# Rules
# Get all rules of a Section, OpenNebula section if it's not defined
# Return:
# - [Array]
def rules(section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules'
@nsx_client.get(url)
end
# Get rule by id
# Return:
# rule | nil
def rule_by_id(rule_id)
url = @base_url + '/rules/' + rule_id
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK,
NSXConstants::CODE_BAD_REQUEST,
NSXConstants::CODE_NOT_FOUND]
additional_headers = []
@nsx_client.get(url, additional_headers, valid_codes)
end
# Get rules by name
# Return:
# - Array with rules or an empty array
def rules_by_name(rule_name, section_id = @one_section_id)
rules = []
return rules unless section_id
all_rules = rules(section_id)
return rules unless all_rules
all_rules['results'].each do |rule|
rules << rule if rule['display_name'] == rule_name
end
rules
end
# Get rule by regex
# Return:
# - Array with rules or an empty array
def rules_by_regex(regex, section_id = @one_section_id)
rules = []
return rules unless section_id
all_rules = rules(section_id)
return rules unless all_rules
all_rules['results'].each do |rule|
rules << rule if rule['display_name'].match(regex)
end
rules
end
# Create new rule
def create_rule(rule_spec, section_id = @one_section_id)
# Get revision from section
section = section_by_id(section_id)
unless section
error_msg = "Section with id #{section_id} not found"
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
end
revision_id = section['_revision']
rule_spec['_revision'] = revision_id
rule_spec = rule_spec.to_json
url = @url_sections + '/' + section_id + '/rules'
@nsx_client.post(url, rule_spec)
end
# Update rule
def update_rule(rule_id, rule_spec, section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules/' + rule_id
rule = rule_by_id(rule_id)
raise "Rule id #{rule_id} not found" unless rule
rule_spec['_revision'] = rule['_revision']
rule_spec = rule_spec.to_json
@nsx_client.put(url, rule_spec)
end
# Delete rule
def delete_rule(rule_id, section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules/' + rule_id
# Delete receive a 200 OK also if the rule doesn't exist
@nsx_client.delete(url)
end
end
end
@@ -0,0 +1,94 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
# Class NSXTLogicalPort
class NSXTLogicalPort < LogicalPort
# ATTRIBUTES
attr_reader :id, :name, :type, :url
# CONSTRUCTOR
# Logical port class variables:
# @lp_id
# @url_lp
# @lp_name
# @lp_type
def initialize(nsx_client, id = nil, data = nil)
super(nsx_client)
# lpid can be:
# - Logical port attach ID
if id
initialize_with_id(id)
else
if data
begin
@id = new_logical_port(data)
rescue NSXError::IncorrectResponseCodeError => e
raise 'Logical Port not created in ' \
"NSX Manager: #{e.message}"
end
unless @id
raise 'Logical Port not created in NSX Manager: '\
'generic error'
end
# Construct logical port class variables
@url = NSXConstants::NSXT_LP_BASE + @id
@name = lp_name
@type = lp_type
end
end
end
# Creates a NSXTLogicalPort from its id
def initialize_with_id(id)
@id = lp_with_attachid(id)
# Construct URL of the created logical switch
@url = NSXConstants::NSXT_LP_BASE + @id
return unless lp?
@name = lp_name
@type = lp_type
end
# Check if logical port exists
def lp?
@nsx_client.get(@url)
end
# Get logical port id from attach id
def lp_with_attachid(attach_id)
lps = @nsx_client.get(NSXConstants::NSXT_LP_BASE)
lps['results'].each do |lp|
return lp['id'] if lp['attachment']['id'] == attach_id
end
end
# # Get logical port display name
def lp_name
lp = @nsx_client.get(@url)
lp['display_name']
end
# # Get resource type
def lp_type
lp = @nsx_client.get(@url)
lp['resource_type']
end
end
end
@@ -0,0 +1,188 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
module NSXRule
# Class Logical Switch
module NSXTRule
def nsxt_rule_spec(rule, vm_data, nic_data)
# default spec
# Allow any-any to any port applied on the
# virtual machine logical port
rule_name = "#{rule[:id]}-#{rule[:name]}-#{vm_data[:id]}"
rule_name << "-#{vm_data[:deploy_id]}-#{nic_data[:id]}"
rule_spec = {
:display_name => rule_name,
:destinations_excluded => false,
:sources => [],
:destinations => [],
:services => [],
:applied_tos => [
{
:target_id => nic_data[:lp].id,
:target_display_name => nic_data[:name],
:target_type => nic_data[:lp].type,
:is_valid => true
}
],
:ip_protocol => 'IPV4_IPV6',
:logged => false,
:action => 'ALLOW',
:sources_excluded => false,
:disabled => false,
:direction => rule[:direction]
}
rule_protocol_template = {
'TCP' => [
{
:service => {
:l4_protocol => 'TCP',
:source_ports => [],
:destination_ports => [],
:resource_type => 'L4PortSetNSService'
}
}
],
'UDP' => [
{
:service => {
:l4_protocol => 'UDP',
:source_ports => [],
:destination_ports => [],
:resource_type => 'L4PortSetNSService'
}
}
],
'ICMP' => [
{
:service => {
:protocol => 'ICMPv4',
:resource_type => 'ICMPTypeNSService'
}
}
],
'ICMPv6' => [
{
:service => {
:protocol => 'ICMPv6',
:resource_type => 'ICMPTypeNSService'
}
}
],
'IPSEC' => [
{
:service => {
:l4_protocol => 'UDP',
:source_ports => [],
:destination_ports => [],
:resource_type => 'L4PortSetNSService'
}
},
{
:service => {
:protocol_number => 50,
:resource_type => 'IPProtocolNSService'
}
},
{
:service => {
:protocol_number => 51,
:resource_type => 'IPProtocolNSService'
}
}
]
}
# Modify default rule spec based on rule_data extracted
# from vm template
###### SOURCES / DESTINATIONS: Any | IP Address | Vnet #####
src_or_dst = []
# Target network: Vnet
if !rule[:network_id].empty?
src_or_dst << {
:target_id => rule[:network_nsxid],
:target_display_name => rule[:network_name],
:target_type => 'LogicalSwitch',
:is_valid => true
}
# Target network: Manual network (IP Address)
elsif !rule[:subnets].empty?
rule[:subnets].each do |subnet|
src_or_dst << {
:target_id => subnet,
:target_display_name => subnet,
:target_type => 'IPAddress',
:is_valid => true
}
end
end
# (OpenNebula) INBOUND => Destination (NSX)
# (OpenNebula) OUTBOUND => Source (NSX)
unless src_or_dst.empty?
rule_spec[:sources] = src_or_dst \
if rule[:direction] == 'IN'
rule_spec[:destinations] = src_or_dst \
if rule[:direction] == 'OUT'
end
##### SERVICES #####
services = []
service = rule_protocol_template[rule[:protocol]]
case rule[:protocol]
when 'TCP'
service[0][:service][:source_ports] = rule[:ports] \
if rule[:direction] == 'IN'
service[0][:service][:destination_ports] = rule[:ports] \
if rule[:direction] == 'OUT'
when 'UDP'
service[0][:service][:source_ports] = rule[:ports] \
if rule[:direction] == 'IN'
service[0][:service][:destination_ports] = rule[:ports] \
if rule[:direction] == 'OUT'
# when 'ICMP'
# when 'ICMPv6'
when 'IPSEC'
ipsec_ports = NSXConstants::NSX_RULE_IPSEC_PORTS
service[0][:service][:source_ports] = ipsec_ports \
if rule[:direction] == 'IN'
service[0][:service][:destination_ports] = ipsec_ports \
if rule[:direction] == 'OUT'
end
if rule[:protocol] != 'ALL' && !service.empty?
service.each do |s|
services << s
end
rule_spec[:services] = services
end
rule_spec
end
end
end
end
@@ -16,7 +16,7 @@
module NSXDriver
# Class Transport Zone
class NSXTtz < NSXDriver::TransportZone
class NSXTtz < TransportZone
# ATTRIBUTES
attr_reader :tz_id
@@ -25,7 +25,7 @@ module NSXDriver
def initialize(nsx_client)
super(nsx_client)
# Construct base URLs
@url_tzs_nsxt = NSXDriver::NSXConstants::NSXT_TZS
@url_tzs_nsxt = NSXConstants::NSXT_TZS
end
# METHODS
@@ -37,7 +37,7 @@ module NSXDriver
$LOAD_PATH << RUBY_LIB_LOCATION
# Class NSXVClient
class NSXVClient < NSXDriver::NSXClient
class NSXVClient < NSXClient
# ATTIBUTES
attr_accessor :nsxmgr
@@ -48,130 +48,120 @@ module NSXDriver
# CONSTRUCTORS
def initialize(nsxmgr, nsx_user, nsx_password)
super(nsxmgr, nsx_user, nsx_password)
@nsx_type = NSXDriver::NSXConstants::NSXV
@nsx_type = NSXConstants::NSXV
end
# Prepare headers
def add_headers(aditional_headers = [])
headers = NSXConstants::HEADER_XML.clone
unless aditional_headers.empty?
aditional_headers.each do |header|
headers[header.keys[0]] = header.values[0]
end
end
headers
end
# METHODS
def get(url)
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Get.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
request.basic_auth(@nsx_user, @nsx_password)
begin
response = Net::HTTP
.start(uri.host,
uri.port,
:use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE)\
do |https|
https.request(request)
end
rescue StandardError => e
raise e
def get(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
return Nokogiri::XML response.body \
if check_response(response, [NSXDriver::NSXConstants::CODE_OK])
uri = URI.parse(@nsxmgr + url)
headers = add_headers(aditional_headers)
request = Net::HTTP::Get.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
Nokogiri::XML response.body
end
def get_full_response(url)
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Get.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
request.basic_auth(@nsx_user, @nsx_password)
begin
response = Net::HTTP
.start(uri.host,
uri.port,
:use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE)\
do |https|
https.request(request)
end
rescue StandardError => e
raise e
def get_full_response(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
return response \
if check_response(response, [NSXDriver::NSXConstants::CODE_OK])
uri = URI.parse(@nsxmgr + url)
headers = add_headers(aditional_headers)
request = Net::HTTP::Get.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, valid_codes)
end
# Return: id of the created object
def post(url, data)
def post(url, data, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Post.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
headers = add_headers(aditional_headers)
request = Net::HTTP::Post.new(uri.request_uri, headers)
request.body = data
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
# If response is different as expected raise the message
unless check_response(response,
[NSXDriver::NSXConstants::CODE_CREATED])
response_json = JSON.parse(response.body)
nsx_error = "\nNSX error code: " \
"#{response_json['errorCode']}, " \
"\nNSX error details: " \
"#{response_json['details']}"
raise NSXDriver::NSXError::IncorrectResponseCodeError, \
nsx_error
end
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response.body
end
def put(url, data)
def put(url, data, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Put.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
headers = add_headers(aditional_headers)
request = Net::HTTP::Put.new(uri.request_uri, headers)
request.body = data
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
# If response is different as expected raise the message
unless check_response(response,
[NSXDriver::NSXConstants::CODE_CREATED])
response_json = JSON.parse(response.body)
nsx_error = "\nNSX error code: " \
"#{response_json['errorCode']}, " \
"\nNSX error details: " \
"#{response_json['details']}"
raise NSXDriver::NSXError::IncorrectResponseCodeError, \
nsx_error
end
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response.body
end
def delete(url)
def delete(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK,
NSXConstants::CODE_NO_CONTENT]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Delete.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
headers = add_headers(aditional_headers)
request = Net::HTTP::Delete.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, [NSXDriver::NSXConstants::CODE_OK])
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
check_response(response, valid_codes)
end
def get_token(url)
def get_token(url, aditional_headers = [], valid_codes = [])
if valid_codes.empty?
valid_codes = [NSXConstants::CODE_OK]
end
uri = URI.parse(@nsxmgr + url)
request = Net::HTTP::Post.new(uri.request_uri,
NSXDriver::NSXConstants::HEADER_XML)
headers = add_headers(aditional_headers)
request = Net::HTTP::Post.new(uri.request_uri, headers)
request.basic_auth(@nsx_user, @nsx_password)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true,
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
return unless check_response(response,
[NSXDriver::NSXConstants::CODE_OK])
:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |https|
https.request(request)
end
response = check_response(response, valid_codes)
response_xml = Nokogiri::XML response.body
token = response_xml.xpath('//authToken/value').text
{ 'token' => token }.to_json
@@ -0,0 +1,204 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
# Class Logical Switch
class NSXVdfw < DistributedFirewall
# ATTRIBUTES
attr_reader :one_section_id
# CONSTRUCTOR
# Creates OpenNebula section if not exists
def initialize(nsx_client)
super(nsx_client)
# Construct base URLs
@base_url = NSXConstants::NSXV_DFW_BASE
@url_sections = @base_url + \
NSXConstants::NSXV_DFW_SECTIONS
@one_section_id = init_section
end
# Sections
# Get all sections
# Creates OpenNebula section if not exists and returns
# its section_id. Returns its section_id if OpenNebula
# section already exists
def init_section
one_section = section_by_name(
NSXConstants::ONE_SECTION_NAME
)
one_section ||= create_section(
NSXConstants::ONE_SECTION_NAME
)
return one_section.xpath('@id').text if one_section
end
# Get all sections
# Params:
# - None
# Return:
# - nil | [Nokogiri::XML::NodeSet] sections
def sections
result = @nsx_client.get(@base_url)
xp = NSXConstants::NSXV_DFW_SECTION_XPATH
sections = result.xpath(xp)
return sections unless sections.empty?
end
# Get section by id
# Params:
# - section_id: [String] ID of the section or @one_section_id
# Return:
# - nil | [Nokogiri::XML::NodeSet] section
def section_by_id(section_id = @one_section_id)
url = @url_sections + '/' + section_id
result = @nsx_client.get(url)
xp = NSXConstants::NSXV_DFW_SECTION_XPATH
section = result.xpath(xp)
return section unless section.empty?
end
# Get section etag needed to manage FW rules
# Params:
# - section_id: [String] ID of the section or @one_section_id
# Return:
# - nil | etag [String] ID of the etag header
def section_etag(section_id = @one_section_id)
url = @url_sections + '/' + section_id
response = @nsx_client.get_full_response(url)
etag = response['etag']
return etag.delete('\"') if etag
end
# Get section by name
# Params:
# - section_name: [String] Name of the section
# Return:
# - nil | [Nokogiri::XML::NodeSet] section
def section_by_name(section_name)
url = @url_sections + '?name=' + section_name
result = @nsx_client.get(url)
xp = NSXConstants::NSXV_DFW_SECTION_XPATH
section = result.xpath(xp)
return section unless section.empty?
end
# Create new section
# Params:
# - section_name [String] Name of the section
# Return:
# - [Nokogiri::XML::NodeSet]
def create_section(section_name)
section_spec =
"<section name=\"#{section_name}\"\
stateless=\"false\" tcpStrict=\"true\" useSid=\"false\">\
</section>"
section = @nsx_client.post(@url_sections, section_spec)
section_id = section.xpath('//section/@id').text
result = section_by_id(section_id)
raise 'Section was not created in DFW' unless result
result
end
# Delete section
# Params:
# - section_id: [String] ID of the section or @one_section_id
def delete_section(section_id = @one_section_id)
url = @url_sections + '/' + section_id
@nsx_client.delete(url)
end
# Rules
# Get all rules
# Params:
# - section_id: [String] ID of the section or @one_section_id
# Return:
# - [Nokogiri::XML::NodeSet]
def rules(section_id = @one_section_id)
url = @url_sections + '/' + section_id
rules = @nsx_client.get(url)
rules.xpath(NSXConstants::NSXV_DFW_RULE_XPATH)
end
# Get rule by id
# Return:
# - rule | nil
def rule_by_id(rule_id, section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules/' + rule_id
valid_codes = [NSXConstants::CODE_CREATED,
NSXConstants::CODE_OK,
NSXConstants::CODE_BAD_REQUEST,
NSXConstants::CODE_NOT_FOUND]
additional_headers = []
result = @nsx_client.get(url, additional_headers, valid_codes)
result.xpath(NSXConstants::NSXV_DFW_RULE_XPATH)
end
# Get rules by name
# Return:
# - [Nokogiri::XML::NodeSet]
def rules_by_name(rule_name, section_id = @one_section_id)
rules = Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new)
all_rules = rules(section_id)
return rules unless all_rules
all_rules.xpath("//rule[name=\"#{rule_name}\"]")
end
# Create new rule
def create_rule(rule_spec, section_id = @one_section_id)
# etag is needed to add a new header If-Match
etag = section_etag(section_id)
raise NSXError::ObjectNotFound('etag') \
unless etag
aditional_headers = [{ 'If-Match' => etag }]
url = @url_sections + '/' + section_id + '/rules'
@nsx_client.post(url, rule_spec, aditional_headers)
end
# Update rule
def update_rule(rule_id, rule_spec, section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules/' + rule_id
rule = rule_by_id(rule_id)
raise "Rule id #{rule_id} not found" unless rule
# etag is needed to add a new header If-Match
etag = section_etag(section_id)
raise "Cannot get etag from section: #{section_id}" unless etag
aditional_headers = [{ 'If-Match' => etag }]
@nsx_client.put(url, rule_spec, aditional_headers)
end
# Delete rule
def delete_rule(rule_id, section_id = @one_section_id)
url = @url_sections + '/' + section_id + '/rules/' + rule_id
# etag is needed to add a new header If-Match
etag = section_etag(section_id)
raise "Cannot get etag from section: #{section_id}" unless etag
aditional_headers = [{ 'If-Match' => etag }]
@nsx_client.delete(url, aditional_headers)
end
end
end
@@ -0,0 +1,106 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
class NSXVLogicalPort < LogicalPort
# ATTRIBUTES
attr_reader :id, :name, :type, :url
# CONSTRUCTOR
# Logical port class variables:
# @lp_id
# @url_lp
# @lp_name
# @lp_type
def initialize(nsx_client, id = nil, data = nil)
super(nsx_client)
# lpid can be:
# - Logical port ID
# - Logical port attach ID
if id
initialize_with_id(id)
else
if data
begin
@id = new_logical_port(data)
rescue NSXError::IncorrectResponseCodeError => e
raise 'Logical Port not created in ' \
"NSX Manager: #{e.message}"
end
unless @id
raise 'Logical Port not created in NSX Manager: '\
'generic error'
end
# Construct logical port class variables
@url = NSXConstants::NSXT_LP_BASE + @id
@name = lp_name
@type = lp_type
end
end
end
# Creates a NSXTLogicalPort from its id
def initialize_with_id(id)
# First try lpid as logical port id
@id = id
# Construct URL of the created logical switch
@url = NSXConstants::NSXV_LP_BASE + @id
if lp?
@name = lp_name
@type = lp_type
else
# Second try with lpid as logical port attach id
@id = lp_with_attachid(id)
if @id.nil?
error_msg = "Logical port with id: #{id} not found"
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
else
@url = NSXConstants::NSXT_LP_BASE + @id
@name = lp_name
@type = lp_type
end
end
end
# Check if logical port exists
def lp?
@nsx_client.get(@url) ? true : false
end
# Get logical port id from attach id
def lp_with_attachid(attach_id)
lps = @nsx_client.get(NSXConstants::NSXT_LP_BASE)
lps['results'].each do |lp|
return lp['id'] if lp['attachment']['id'] == attach_id
end
end
# Get logical port display name
def lp_name
@nsx_client.get(@url)['display_name']
end
# Get resource type
def lp_type
@nsx_client.get(@url)['resource_type']
end
end
end
@@ -0,0 +1,172 @@
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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 NSXDriver
module NSXRule
# Module NSXVRule
module NSXVRule
def nsxv_rule_spec(rule, vm_data, nic_data)
rule_name = "#{rule[:id]}-#{rule[:name]}-#{vm_data[:id]}"
rule_name << "-#{vm_data[:deploy_id]}-#{nic_data[:id]}"
# rubocop:disable Layout/LineLength
builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
# rubocop:enable Layout/LineLength
xml.rule('disabled' => 'false', 'logged' => 'false') do
xml.name rule_name
xml.action 'allow'
xml.appliedToList do
xml.appliedTo do
xml.name nic_data[:name]
xml.value nic_data[:lp]
xml.type 'Vnic'
xml.isValid 'true'
end
end
xml.sectionId @one_section_id
# SOURCES / DESTINATIONS: Any | IP Address | Vnet
unless rule[:network_id].empty? && rule[:subnets].empty?
if rule[:direction] == 'IN'
xml.sources('excluded' => 'false') do
if !rule[:network_id].empty?
xml.source do
xml.name rule[:network_name]
xml.value rule[:network_nsxid]
xml.type 'VirtualWire'
xml.isValid 'true'
end
elsif !rule[:subnets].empty?
rule[:subnets].each do |subnet|
xml.source do
# rubocop:disable Layout/LineLength
ip_version = IPAddr.new(subnet).ipv4? ? 'Ipv4Address' : 'Ipv6Address'
# rubocop:enable Layout/LineLength
xml.value subnet
xml.type ip_version
xml.isValid 'true'
end
end
end
end
else
xml.destinations('excluded' => 'false') do
# Target network: Vnet
if !rule[:network_id].empty?
xml.destination do
xml.name nic_data[:network_name]
xml.value rule[:network_nsxid]
xml.type 'VirtualWire'
xml.isValid 'true'
end
# Target network: Manual network(IP Address)
elsif !rule[:subnets].empty?
rule[:subnets].each do |subnet|
xml.destination do
# rubocop:disable Layout/LineLength
ip_version = IPAddr.new(subnet).ipv4? ? 'Ipv4Address' : 'Ipv6Address'
# rubocop:enable Layout/LineLength
xml.value subnet
xml.type ip_version
xml.isValid 'true'
end
end
end
end
end
end
##### SERVICES #####
unless rule[:protocol].empty?
xml.services do
case rule[:protocol]
when 'TCP'
xml.service do
xml.isValid 'true'
xml.protocol '6'
xml.protocolName 'TCP'
# rubocop:disable Layout/LineLength
xml.sourcePort parse_ports(rule[:ports]) \
if rule[:direction] == 'IN'
xml.destinationPort parse_ports(rule[:ports]) \
if rule[:direction] == 'OUT'
# rubocop:enable Layout/LineLength
end
when 'UDP'
xml.service do
xml.isValid 'true'
xml.protocol '17'
xml.protocolName 'UDP'
# rubocop:disable Layout/LineLength
xml.sourcePort parse_ports(rule[:ports]) \
if rule[:direction] == 'IN'
xml.destinationPort parse_ports(rule[:ports]) \
if rule[:direction] == 'OUT'
# rubocop:enable Layout/LineLength
end
when 'ICMP'
xml.service do
xml.isValid 'true'
xml.protocol '1'
xml.protocolName 'ICMP'
end
when 'ICMPv6'
xml.service do
xml.isValid 'true'
xml.protocol '58'
xml.protocolName 'IPV6ICMP'
end
when 'IPSEC'
ports = NSXConstants::NSX_RULE_IPSEC_PORTS
xml.service do
xml.isValid 'true'
xml.protocol '50'
xml.protocolName 'ESP'
end
xml.service do
xml.isValid 'true'
xml.protocol '51'
xml.protocolName 'AH'
end
xml.service do
xml.isValid 'true'
xml.protocol '17'
xml.protocolName 'UDP'
xml.sourcePort parse_ports(ports) \
if rule[:direction] == 'IN'
xml.destinationPort parse_ports(ports) \
if rule[:direction] == 'OUT'
end
end
end
end
xml.direction rule[:direction].downcase
xml.packetType 'any'
end
end
builder.to_xml
end
end
end
end
@@ -16,7 +16,7 @@
module NSXDriver
# Class Transport Zone
class NSXVtz < NSXDriver::TransportZone
class NSXVtz < TransportZone
# ATTRIBUTES
attr_reader :tz_id
@@ -25,7 +25,7 @@ module NSXDriver
def initialize(nsx_client)
super(nsx_client)
# Construct base URLs
@url_tzs_nsxv = NSXDriver::NSXConstants::NSXV_TZS
@url_tzs_nsxv = NSXConstants::NSXV_TZS
end
# METHODS
@@ -33,7 +33,7 @@ module NSXDriver
def tzs
@nsx_client
.get(@url_tzs_nsxv)
.xpath(NSXDriver::NSXConstants::NSXV_TZS_XPATH)
.xpath(NSXConstants::NSXV_TZS_XPATH)
end
end
@@ -16,7 +16,7 @@
module NSXDriver
# Class Opaque Network NSX-T Network
class OpaqueNetwork < NSXDriver::LogicalSwitch
class OpaqueNetwork < LogicalSwitch
# ATTRIBUTES
# attr_reader :ls_id, :admin_display
@@ -31,7 +31,7 @@ module NSXDriver
if ls_data
begin
@ls_id = new_logical_switch(ls_data)
rescue NSXDriver::NSXError::
rescue NSXError::
IncorrectResponseCodeError => e
raise 'Opaque Network not created in ' \
"NSX Manager: #{e.message}"
@@ -42,7 +42,7 @@ module NSXDriver
end
# Construct URL of the created logical switch
@url_ls = NSXDriver::NSXConstants::NSXT_LS_SECTION + \
@url_ls = NSXConstants::NSXT_LS_SECTION + \
@ls_id
@ls_vni = ls_vni
@ls_name = ls_name
@@ -53,13 +53,13 @@ module NSXDriver
end
end
# Creates a NSXDriver::OpaqueNetwork from its name
# Creates a OpaqueNetwork from its name
def self.new_from_name(nsx_client, ls_name)
lswitch = new(nsx_client)
ls_id = lswitch.ls_id_from_name(nsx_client, ls_name)
unless ls_id
error_msg = "Opaque Network with name: #{ls_name} not found"
error = NSXDriver::NSXError::ObjectNotFound
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
end
@@ -69,11 +69,11 @@ module NSXDriver
lswitch
end
# Creates a NSXDriver::OpaqueNetwork from its id
# Creates a OpaqueNetwork from its id
def initialize_with_id(ls_id)
@ls_id = ls_id
# Construct URL of the created logical switch
@url_ls = NSXDriver::NSXConstants::NSXT_LS_SECTION + \
@url_ls = NSXConstants::NSXT_LS_SECTION + \
@ls_id
if ls?
@ls_vni = ls_vni
@@ -82,7 +82,7 @@ module NSXDriver
@admin_display = 'UP'
else
error_msg = "Opaque Network with id: #{ls_id} not found"
error = NSXDriver::NSXError::ObjectNotFound
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
end
@@ -90,7 +90,7 @@ module NSXDriver
# Get the logical switch id from its name
def ls_id_from_name(nsx_client, name)
url = NSXDriver::NSXConstants::NSXT_LS_SECTION
url = NSXConstants::NSXT_LS_SECTION
lswitches = nsx_client.get(url)['results']
lswitches.each do |lswitch|
lsname = lswitch['display_name']
@@ -125,7 +125,7 @@ module NSXDriver
# Create a new logical switch (NSX-T: opaque network)
def new_logical_switch(ls_data)
@nsx_client.post(NSXDriver::NSXConstants::NSXT_LS_SECTION, ls_data)
@nsx_client.post(NSXConstants::NSXT_LS_SECTION, ls_data)
end
# Delete a logical switch
@@ -16,7 +16,7 @@
module NSXDriver
# Class Transport Zone
class TransportZone < NSXDriver::NSXComponent
class TransportZone < NSXComponent
# ATTRIBUTES
attr_reader :tz_id
@@ -28,13 +28,13 @@ module NSXDriver
def self.new_child(nsx_client)
case nsx_client.nsx_type.upcase
when NSXDriver::NSXConstants::NSXT
NSXDriver::NSXTtz.new(nsx_client)
when NSXDriver::NSXConstants::NSXV
NSXDriver::NSXVtz.new(nsx_client)
when NSXConstants::NSXT
NSXTtz.new(nsx_client)
when NSXConstants::NSXV
NSXVtz.new(nsx_client)
else
error_msg = "Unknown object type: #{nsx_client.nsx_type}"
error = NSXDriver::NSXError::UnknownObject.new(error_msg)
error = NSXError::UnknownObject.new(error_msg)
raise error
end
end
@@ -16,7 +16,7 @@
module NSXDriver
# Class VirtualWire NSX-V Network
class VirtualWire < NSXDriver::LogicalSwitch
class VirtualWire < LogicalSwitch
# CONSTRUCTOR
def initialize(nsx_client, ls_id = nil, tz_id = nil, ls_data = nil)
@@ -28,7 +28,7 @@ module NSXDriver
if ls_data
begin
@ls_id = new_logical_switch(ls_data, tz_id)
rescue NSXDriver::NSXError::
rescue NSXError::
IncorrectResponseCodeError => e
raise 'VirtualWire not created in NSX Manager: ' \
"#{e.message}"
@@ -39,7 +39,7 @@ module NSXDriver
end
# Construct URL of the created logical switch
@url_ls = NSXDriver::NSXConstants::NSXV_LS_SECTION + \
@url_ls = NSXConstants::NSXV_LS_SECTION + \
@ls_id
@ls_vni = ls_vni
@ls_name = ls_name
@@ -51,13 +51,13 @@ module NSXDriver
end
end
# Creates a NSXDriver::VirtualWire from its name
# Creates a VirtualWire from its name
def self.new_from_name(nsx_client, ls_name)
virtualwire = new(nsx_client)
ls_id = virtualwire.ls_id_from_name(nsx_client, ls_name)
unless ls_id
error_msg = "VirtualWire with name: #{ls_name} not found"
error = NSXDriver::NSXError::ObjectNotFound
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
end
@@ -67,16 +67,16 @@ module NSXDriver
virtualwire
end
# Creates a NSXDriver::VirtualWire from its id
# Creates a VirtualWire from its id
def initialize_with_id(ls_id)
@ls_id = ls_id
# Construct URL of the created logical switch
@url_ls = NSXDriver::NSXConstants::NSXV_LS_SECTION + \
@url_ls = NSXConstants::NSXV_LS_SECTION + \
@ls_id
# Raise an error if VirtualWire id doesn't exists
unless ls?
error_msg = "VirtualWire with id: #{ls_id} not found"
error = NSXDriver::NSXError::ObjectNotFound
error = NSXError::ObjectNotFound
.new(error_msg)
raise error
end
@@ -90,10 +90,10 @@ module NSXDriver
# Get the logical switch id from its name
def ls_id_from_name(nsx_client, name)
url = NSXDriver::NSXConstants::NSXV_LS_SECTION
url = NSXConstants::NSXV_LS_SECTION
virtualwires = nsx_client
.get(url)
.xpath(NSXDriver::NSXConstants::NSXV_LS_XPATH)
.xpath(NSXConstants::NSXV_LS_XPATH)
virtualwires.each do |virtualwire|
lsname_arr = name.split(/-sid-/)
lsname = lsname_arr[-1].split('-', 2)[-1]
@@ -116,38 +116,38 @@ module NSXDriver
# Get logical switch's name
def ls_name
@nsx_client.get(@url_ls)
.xpath(NSXDriver::NSXConstants::NSXV_LS_NAME_XPATH).text
.xpath(NSXConstants::NSXV_LS_NAME_XPATH).text
end
# Get logical switch's vni
def ls_vni
@nsx_client.get(@url_ls)
.xpath(NSXDriver::NSXConstants::NSXV_LS_VNI_XPATH).text
.xpath(NSXConstants::NSXV_LS_VNI_XPATH).text
end
# Get the Transport Zone of the logical switch
def ls_tz
@nsx_client.get(@url_ls)
.xpath(NSXDriver::NSXConstants::NSXV_TZ_XPATH).text
.xpath(NSXConstants::NSXV_TZ_XPATH).text
end
# Get the logical switch reference into vcenter
def ls_vcenter_ref
@nsx_client.get(@url_ls)
.xpath(NSXDriver::NSXConstants::NSXV_LS_BACKING_XPATH)
.xpath(NSXConstants::NSXV_LS_BACKING_XPATH)
.text
end
# Get the distributed virtual switch's ref associated to a LS
def ls_dvs_ref
@nsx_client.get(@url_ls)
.xpath(NSXDriver::NSXConstants::NSXV_LS_OBJECTID_XPATH)
.xpath(NSXConstants::NSXV_LS_OBJECTID_XPATH)
.text
end
# Create a new logical switch (NSX-V: virtualwire)
def new_logical_switch(ls_data, tz_id)
url = "#{NSXDriver::NSXConstants::NSXV_TZ_SECTION}#{tz_id}" \
url = "#{NSXConstants::NSXV_TZ_SECTION}#{tz_id}" \
'/virtualwires'
@nsx_client.post(url, ls_data)
end
+9
View File
@@ -59,6 +59,15 @@ require 'transport_zone'
require 'nsxt_tz'
require 'nsxv_tz'
require 'virtual_wire'
require 'distributed_firewall'
require 'nsxt_dfw'
require 'nsxv_dfw'
require 'logical_port'
require 'nsxt_logical_port'
require 'nsxv_logical_port'
require 'nsx_rule'
require 'nsxt_rule'
require 'nsxv_rule'
# NSX Driver module
module NSXDriver
-1
View File
@@ -1 +0,0 @@
../common/dummy.sh
+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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. #
#--------------------------------------------------------------------------- #
# Define libraries location
ONE_LOCATION = ENV['ONE_LOCATION']
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
GEMS_LOCATION = '/usr/share/one/gems'
VMDIR = '/var/lib/one'
CONFIG_FILE = '/var/lib/one/config'
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
VMDIR = ONE_LOCATION + '/var'
CONFIG_FILE = ONE_LOCATION + '/var/config'
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
$LOAD_PATH << File.dirname(__FILE__)
$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
require 'vnmmad'
require 'nokogiri'
require 'opennebula'
require 'vcenter_driver'
require 'nsx_driver'
def modified?(template)
template_xml = Nokogiri::XML(template)
action = template_xml.xpath('//TEMPLATE/NIC[ATTACH="YES"]')
action.empty? ? false : true
end
template = Base64.decode64(STDIN.read)
template_xml = Nokogiri::XML(template)
# Check Host exists
host_name = template_xml
.xpath('//HISTORY_RECORDS/HISTORY[last()]/HOSTNAME').text
one_host = VCenterDriver::VIHelper
.find_by_name(OpenNebula::HostPool, host_name)
rc = one_host.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
# Exit with error if NSX_STATUS != OK
nsx_status = one_host['TEMPLATE/NSX_STATUS']
unless nsx_status == 'OK'
OpenNebula.log_error('NSX_STATUS is not OK')
OpenNebula.error_message('NSX_STATUS is not OK')
exit 1
end
# Clear rules
nsx_client = NSXDriver::NSXClient.new_from_id(one_host['ID'])
dfw = NSXDriver::DistributedFirewall.new_child(nsx_client)
begin
dfw.clear_rules(template, modified?(template))
rescue StandardError => e
OpenNebula.log_error('Error deleting security groups rules ' \
"due to \"#{e.message}\"")
if VCenterDriver::CONFIG[:debug_information]
OpenNebula.error_message(e.backtrace)
end
exit 1
end
exit 0
-1
View File
@@ -1 +0,0 @@
../common/dummy.sh
+103
View File
@@ -0,0 +1,103 @@
#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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. #
#--------------------------------------------------------------------------- #
# Define libraries location
ONE_LOCATION = ENV['ONE_LOCATION']
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
GEMS_LOCATION = '/usr/share/one/gems'
VMDIR = '/var/lib/one'
CONFIG_FILE = '/var/lib/one/config'
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
VMDIR = ONE_LOCATION + '/var'
CONFIG_FILE = ONE_LOCATION + '/var/config'
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
$LOAD_PATH << File.dirname(__FILE__)
$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
require 'vnmmad'
require 'nokogiri'
require 'opennebula'
require 'vcenter_driver'
require 'nsx_driver'
def modified?(template)
template_xml = Nokogiri::XML(template)
action = template_xml.xpath('//TEMPLATE/NIC[ATTACH="YES"]')
action.empty? ? false : true
end
template = Base64.decode64(STDIN.read)
deploy_id = ARGV[0]
template_xml = Nokogiri::XML(template)
# OpenNebula host
host_name = template_xml
.xpath('//HISTORY_RECORDS/HISTORY[last()]/HOSTNAME').text
one_host = VCenterDriver::VIHelper
.find_by_name(OpenNebula::HostPool, host_name)
rc = one_host.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
# OpenNebula VM
vmid = template_xml.xpath('//VM/ID')
one_vm = VCenterDriver::VIHelper.one_item(OpenNebula::VirtualMachine, vmid)
rc = one_vm.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
# NSX Objects
nsx_client = NSXDriver::NSXTClient.new_from_id(one_host['ID'])
dfw = NSXDriver::DistributedFirewall.new_child(nsx_client)
ls = NSXDriver::LogicalSwitch.new(nsx_client)
# Get all modified or all NSX Nics
is_modified = modified?(template)
nsx_nics = ls.nsx_nics(template_xml, is_modified)
vm_state = one_vm.state_str
unless nsx_nics.empty? || (vm_state == 'POWEROFF')
begin
dfw.create_rules(deploy_id, template, is_modified)
rescue StandardError => e
dfw.clear_rules(template, is_modified)
OpenNebula.log_error('Error creating Security Group rules ' \
"due to \"#{e.message}\"")
if VCenterDriver::CONFIG[:debug_information]
OpenNebula.error_message(e.backtrace)
end
exit 1
end
end
exit 0
-1
View File
@@ -1 +0,0 @@
../common/dummy.sh
+71
View File
@@ -0,0 +1,71 @@
#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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. #
#--------------------------------------------------------------------------- #
# Define libraries location
ONE_LOCATION = ENV['ONE_LOCATION']
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
GEMS_LOCATION = '/usr/share/one/gems'
VMDIR = '/var/lib/one'
CONFIG_FILE = '/var/lib/one/config'
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
VMDIR = ONE_LOCATION + '/var'
CONFIG_FILE = ONE_LOCATION + '/var/config'
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
$LOAD_PATH << File.dirname(__FILE__)
$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
require 'vnmmad'
require 'nokogiri'
require 'opennebula'
require 'vcenter_driver'
require 'nsx_driver'
template = Base64.decode64(STDIN.read)
template_xml = Nokogiri::XML(template)
# Check Host exists
host_name = template_xml
.xpath('//HISTORY_RECORDS/HISTORY[last()]/HOSTNAME').text
one_host = VCenterDriver::VIHelper
.find_by_name(OpenNebula::HostPool, host_name)
rc = one_host.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
# Exit with error if NSX_STATUS != OK
nsx_status = one_host['TEMPLATE/NSX_STATUS']
unless nsx_status == 'OK'
OpenNebula.log_error('NSX_STATUS is not OK')
OpenNebula.error_message('NSX_STATUS is not OK')
exit 1
end
exit 0
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env ruby
# -------------------------------------------------------------------------- #
# Copyright 2002-2019, 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. #
#--------------------------------------------------------------------------- #
# Define libraries location
ONE_LOCATION = ENV['ONE_LOCATION']
if !ONE_LOCATION
RUBY_LIB_LOCATION = '/usr/lib/one/ruby'
GEMS_LOCATION = '/usr/share/one/gems'
VMDIR = '/var/lib/one'
CONFIG_FILE = '/var/lib/one/config'
else
RUBY_LIB_LOCATION = ONE_LOCATION + '/lib/ruby'
GEMS_LOCATION = ONE_LOCATION + '/share/gems'
VMDIR = ONE_LOCATION + '/var'
CONFIG_FILE = ONE_LOCATION + '/var/config'
end
if File.directory?(GEMS_LOCATION)
Gem.use_paths(GEMS_LOCATION)
end
$LOAD_PATH << RUBY_LIB_LOCATION
$LOAD_PATH << File.dirname(__FILE__)
$LOAD_PATH << File.join(File.dirname(__FILE__), '..')
require 'vnmmad'
require 'nokogiri'
require 'opennebula'
require 'vcenter_driver'
require 'nsx_driver'
def modified?(template)
template_xml = Nokogiri::XML(template)
action = template_xml.xpath('//TEMPLATE/NIC[ATTACH="YES"]')
action.empty? ? false : true
end
template = Base64.decode64(STDIN.read)
deploy_id = ARGV[0]
template_xml = Nokogiri::XML(template)
# OpenNebula host
host_name = template_xml
.xpath('//HISTORY_RECORDS/HISTORY[last()]/HOSTNAME').text
one_host = VCenterDriver::VIHelper
.find_by_name(OpenNebula::HostPool, host_name)
rc = one_host.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
vmid = template_xml.xpath('//VM/ID')
one_vm = VCenterDriver::VIHelper.one_item(OpenNebula::VirtualMachine, vmid)
# OpenNebula VM
rc = one_vm.info
if OpenNebula.is_error?(rc)
err_msg = rc.message
raise err_msg
end
# NSX Objects
nsx_client = NSXDriver::NSXTClient.new_from_id(one_host['ID'])
dfw = NSXDriver::DistributedFirewall.new_child(nsx_client)
vm_state = one_vm.state_str
unless vm_state == 'POWEROFF'
begin
dfw.clear_rules(template, false)
dfw.create_rules(deploy_id, template, false)
rescue StandardError => e
OpenNebula.log_error('Error updating security groups ' \
"due to \"#{e.message}\"")
if VCenterDriver::CONFIG[:debug_information]
OpenNebula.error_message(e.backtrace)
end
exit 1
end
end
exit 0