def update_vip(self, new_vip):
vs_ipaddress = new_vip['address']
vs_port = new_vip['protocol_port']
vs_name = new_vip['name']
vs_server_port = self._adx_server_port(vs_ipaddress, vs_port, vs_name)
new_session_persistence = new_vip.get('session_persistence')
LOG.debug('Update Session Persistence')
if new_session_persistence is None:
try:
(self.slb_service.disableStickyOnVirtualServerPort(
vs_server_port))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
else:
type = new_vip['session_persistence']['type']
if type == 'SOURCE_IP':
try:
(self.slb_service.enableStickyOnVirtualServerPort(
vs_server_port))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
else:
error_message = ('Session Persistence of type %s '
'not supported') % (type)
LOG.error(error_message)
raise adx_exception.UnsupportedFeature(msg=error_message)
def delete_member(self, member):
try:
pool_del = False
rsserverport = self._adx_server_port(member['address'],
member['protocol_port'])
rsportbyvirtualcount = self._get_server_port_by_virtual_count(
rsserverport)
if rsportbyvirtualcount == 0:
pool_del = True
rsportbyserver = self._is_server_port(rsserverport)
if rsportbyserver:
self.slb_service.deleteRealServerPort(rsserverport)
# Delete the Real Server
# if this is the only port other than default port
time.sleep(5)
rsportcount = self._get_server_port_count(member['address'], False)
# work around to delete real
if rsportcount <= 1:
pool_del = True
self.slb_service.deleteRealServer(rsserverport.srvr)
return pool_del
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def _update_virtual_server_properties(self, new_vip, old_vip):
try:
address = new_vip['address']
new_description = new_vip.get('description')
old_description = old_vip.get('description')
if new_description == old_description:
return
vs_server = self._adx_server(address)
reply = (self.slb_service.getVirtualServerConfiguration(vs_server))
vs_conf_seq = (self.slb_factory.create(
'ArrayOfVirtualServerConfigurationSequence'))
if new_description:
reply.vipConfig.description = new_description
# Workaround for the XML API Issues
if reply.vipConfig.stickyAge == 0:
reply.vipConfig.stickyAge = None
if reply.vipConfig.tcpAge == 0:
reply.vipConfig.tcpAge = None
if reply.vipConfig.udpAge == 0:
reply.vipConfig.udpAge = None
vs_conf_list = []
vs_conf_list.append(reply.vipConfig)
vs_conf_seq.VirtualServerConfigurationSequence = vs_conf_list
(self.slb_service.setVirtualServersConfiguration(vs_conf_seq))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def bind_monitor_to_member(self, healthmonitor, member):
healthmonitor_name = healthmonitor['id']
rs_ip_address = member['address']
rs_port = member['protocol_port']
rs_name = member.get('name', rs_ip_address)
rs_admin_state = member.get('admin_state_up', 'DISABLED')
rs_run_time_status = 'UNDEFINED'
try:
rs_server_port = self._adx_server_port(rs_ip_address, rs_port,
rs_name)
real_server_port_config = (
self.slb_factory.create('RealServerPortConfiguration'))
real_server_port_config.serverPort = rs_server_port
real_server_port_config.adminState = rs_admin_state
real_server_port_config.runTimeStatus = rs_run_time_status
real_server_port_config.portPolicyName = healthmonitor_name
real_server_port_config.enablePeriodicHealthCheck = True
rs_port_seq = (self.slb_factory.create(
'ArrayOfRealServerPortConfigurationSequence'))
(rs_port_seq.RealServerPortConfigurationSequence.append(
real_server_port_config))
self.slb_service.setRealServersPortConfiguration(rs_port_seq)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def enable_source_nat(self):
try:
global_config = self.slb_factory.create('GlobalSlbConfiguration')
global_config.enableSourceNat = True
self.slb_service.updateSlbGlobalConfiguration(global_config)
except suds.WebFault as e:
LOG.debug(('Exception enabling source nat %s'), e)
raise adx_exception.ConfigError(msg=e.message)
def delete_pool(self, pool):
pool_name = pool['name']
try:
server_group_list = (
self.slb_factory.create('ArrayOfStringSequence'))
server_group_list.StringSequence.append(pool_name)
(self.slb_service.deleteRealServerGroups(server_group_list))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def set_l2l3l4_health_check(self, new_hm, old_hm=None):
try:
delay = new_hm['delay']
self._validate_delay('PING', delay)
max_retries = new_hm['max_retries']
self._validate_max_retries('PING', max_retries)
l2l3l4_health_check = (
self.slb_factory.create('L2L3L4HealthCheck'))
l2l3l4_health_check.pingInterval = delay
l2l3l4_health_check.pingRetries = max_retries
self.slb_service.setL2L3L4HealthCheck(l2l3l4_health_check)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def _create_real_server_port(self, member):
address = member['address']
port = member['protocol_port']
admin_state_up = member['admin_state_up']
name = member.get('name', address)
is_backup = member.get('is_backup', False)
max_connections = member['max_connections']
healthcheck = member.get('healthcheck')
try:
# Create Port Profile if it is not a standard port
if port not in ADX_STANDARD_PORTS:
port_profile = dict()
port_profile['protocol_port'] = port
self._create_port_profile(port_profile)
rs_server_port = self._adx_server_port(address, port, name)
rs_port_seq = (self.slb_factory.create(
'ArrayOfRealServerPortConfigurationSequence'))
rs_port_config = (
self.slb_factory.create('RealServerPortConfiguration'))
rs_port_config.serverPort = rs_server_port
rs_port_config.adminState = admin_state_up
rs_port_config.maxConnection = max_connections
rs_port_config.isBackup = is_backup
if healthcheck:
port_policy = self._create_update_port_policy(healthcheck)
if port_policy.get('sslPolInfo'):
rs_port_config.sslPolInfo = port_policy.get('sslPolInfo')
if port_policy.get('l4Check'):
rs_port_config.enableL4CheckOnly = port_policy.get(
'l4Check')
if port_policy.get('httpPolInfo'):
rs_port_config.httpPolInfo = port_policy.get('httpPolInfo')
# Work Around to define a value for Enumeration Type
rs_port_config.runTimeStatus = 'UNDEFINED'
(rs_port_seq.RealServerPortConfigurationSequence.append(
rs_port_config))
self.slb_service.createRealServerPortWithConfiguration(rs_port_seq)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def delete_vip(self, vip):
address = vip['address']
port = vip['protocol_port']
vs_server_port = self._adx_server_port(address, port)
vip_port_count = self._get_server_port_count(address, True)
try:
self.slb_service.deleteVirtualServerPort(vs_server_port)
except suds.WebFault:
pass
try:
if vip_port_count <= 2:
self.slb_service.deleteVirtualServer(vs_server_port.srvr)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def bind_member_to_vip(self, member, vip):
rs_ip_address = member['address']
rs_port = member['protocol_port']
rs_name = member.get('name', rs_ip_address)
vs_ip_address = vip['address']
vs_port = vip['protocol_port']
vs_name = vip['name']
try:
vs_server_port = self._adx_server_port(vs_ip_address, vs_port,
vs_name)
rs_server_port = self._adx_server_port(rs_ip_address, rs_port,
rs_name)
(self.slb_service.bindRealServerPortToVipPort(
vs_server_port, rs_server_port))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def create_static_route(self, dest_ip_address, network_mask,
nexthop_ip_address):
try:
static_route = self.net_factory.create('StaticRoute')
static_route_seq = (
self.net_factory.create('ArrayOfStaticRouteSequence'))
static_route.staticRouteType = 'STANDARD'
static_route.ipVersion = 'IPV4'
static_route.destIPAddress = dest_ip_address
static_route.networkMaskBits = network_mask
static_route.nexthopIPAddress = nexthop_ip_address
static_route_seq.StaticRouteSequence.append(static_route)
self.net_service.createStaticRoute(static_route_seq)
except suds.WebFault as e:
LOG.debug('Exception configuring static route %s', e)
raise adx_exception.ConfigError(msg=e.message)
def _update_real_server_port_properties(self, new_member):
try:
address = new_member['address']
protocol_port = new_member['protocol_port']
new_admin_state_up = new_member.get('admin_state_up')
max_connections = new_member['max_connections']
healthcheck = new_member.get('healthcheck')
rs_server_port = self._adx_server_port(address, protocol_port)
reply = (self.slb_service.getRealServerPortConfiguration(
rs_server_port))
rs_port_conf_seq = (self.slb_factory.create(
'ArrayOfRealServerPortConfigurationSequence'))
reply.rsPortConfig.serverPort = rs_server_port
reply.rsPortConfig.maxConnection = max_connections
reply.rsPortConfig.adminState = new_admin_state_up
if healthcheck:
port_policy = self._create_update_port_policy(healthcheck)
if port_policy.get('sslPolInfo'):
reply.rsPortConfig.sslPolInfo = port_policy.get(
'sslPolInfo')
else:
reply.rsPortConfig.sslPolInfo = None
if port_policy.get('l4Check'):
reply.rsPortConfig.enableL4CheckOnly = port_policy.get(
'l4Check')
if port_policy.get('httpPolInfo'):
reply.rsPortConfig.httpPolInfo = port_policy.get(
'httpPolInfo')
else:
reply.rsPortConfig.httpPolInfo = None
rs_port_conf_list = [reply.rsPortConfig]
rs_port_conf_seq.RealServerPortConfigurationSequence = rs_port_conf_list
(self.slb_service.setRealServersPortConfiguration(rs_port_conf_seq)
)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def delete_health_monitor(self, healthmonitor):
name = healthmonitor['id']
monitor_type = healthmonitor['type']
if monitor_type in ['HTTP', 'HTTPS', 'TCP']:
if not self._does_port_policy_exist(healthmonitor):
LOG.debug('Health Monitor %s does not '
'exist on the device', name)
return
if not self._is_port_policy_in_use(name):
try:
(self.slb_service.deletePortPolicy(name))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
elif monitor_type == 'PING':
m = 'Delete of PING Monitor not supported'
LOG.error(m)
raise adx_exception.UnsupportedFeature(msg=m)
def create_virtual_server(self, vip):
vs_name = vip['name']
vs_ip_address = vip['address']
vs_port = vip['protocol_port']
description = vip['description']
tos = vip.get('tos')
l4_protocol = vip.get('l4_protocol')
timeout = vip.get('timeout')
server_port = self._adx_server_port(vs_ip_address, vs_port, vs_name)
try:
vs_seq = (self.slb_factory.create(
'ArrayOfVirtualServerConfigurationSequence'))
vs_config = (self.slb_factory.create('VirtualServerConfiguration'))
vs_config.virtualServer = server_port.srvr
vs_config.adminState = True
vs_config.allowAdvertiseVipRoute = True
vs_config.enableAdvertiseVipRoute = True
vs_config.description = description
if tos:
vs_config.tosMarking = tos
vs_config.enableHealthCheckLayer3DSR = True
if l4_protocol == 'TCP':
vs_config.tcpAge = timeout
else:
vs_config.udpAge = timeout
# Work Around to define a value for Enumeration Type
vs_config.predictor = 'ROUND_ROBIN'
vs_config.trackingMode = 'NONE'
vs_config.haMode = 'NOT_CONFIGURED'
(vs_seq.VirtualServerConfigurationSequence.append(vs_config))
(self.slb_service.createVirtualServerWithConfiguration(vs_seq))
except suds.WebFault as e:
LOG.error(
'Exception in create_virtual_server '
'in device driver : %s', e.message)
raise adx_exception.ConfigError(msg=e.message)
def set_predictor_on_virtual_server(self, vip):
try:
server = self._adx_server(vip['address'], vip['name'])
lb_method = vip['lb_method']
predictor_method_configuration = (
self.slb_factory.create('PredictorMethodConfiguration'))
predictor = ADX_PREDICTOR_MAP.get(lb_method)
if predictor:
predictor_method_configuration.predictor = predictor
else:
error_message = ('Load Balancing Method/Predictor %s '
'not supported') % (lb_method)
LOG.error(error_message)
raise adx_exception.UnsupportedFeature(msg=error_message)
(self.slb_service.setPredictorOnVirtualServer(
server, predictor_method_configuration))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def create_virtual_server_port(self, vip):
vs_name = vip['name']
vs_ip_address = vip['address']
vs_port = vip['protocol_port']
admin_state_up = vip.get('admin_state_up', 'DISABLED')
l4_protocol = vip.get('l4_protocol')
try:
server_port = self._adx_server_port(vs_ip_address, vs_port,
vs_name)
vs_port_seq = (self.slb_factory.create(
'ArrayOfVirtualServerPortConfigurationSequence'))
vs_port_config = (
self.slb_factory.create('VirtualServerPortConfiguration'))
vs_port_config.virtualServer = server_port.srvr
vs_port_config.port = server_port.port
vs_port_config.adminState = admin_state_up
if l4_protocol == 'TCP':
vs_port_config.tcpOnly = True
else:
vs_port_config.udpOnly = True
session_persistence = vip.get('session_persistence')
if session_persistence:
sp_type = session_persistence['type']
if sp_type == 'SOURCE_IP':
vs_port_config.enableSticky = True
else:
error_message = ('Session Persistence of type %s '
'not supported') % (sp_type)
LOG.error(error_message)
raise adx_exception.UnsupportedFeature(msg=error_message)
(vs_port_seq.VirtualServerPortConfigurationSequence.append(
vs_port_config))
(self.slb_service.createVirtualServerPortWithConfiguration(
vs_port_seq))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def _update_real_server_port_status(self, new_member):
try:
address = new_member['address']
protocol_port = new_member['protocol_port']
new_admin_state_up = new_member.get('admin_state_up')
rs_server_port = self._adx_server_port(address, protocol_port)
reply = (self.slb_service.getRealServerPortConfiguration(
rs_server_port))
rs_port_conf_seq = (self.slb_factory.create(
'ArrayOfRealServerPortConfigurationSequence'))
reply.rsPortConfig.serverPort = rs_server_port
reply.rsPortConfig.adminState = new_admin_state_up
rs_port_conf_list = [reply.rsPortConfig]
rs_port_conf_seq.RealServerPortConfigurationSequence = rs_port_conf_list
(self.slb_service.setRealServersPortConfiguration(rs_port_conf_seq)
)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def create_pool(self, pool):
pool_name = pool['name']
try:
server_group_list = (
self.slb_factory.create('ArrayOfRealServerGroupSequence'))
real_server_group = (self.slb_factory.create('RealServerGroup'))
real_server_group.groupName = pool_name
server_group_list.RealServerGroupSequence.append(real_server_group)
real_servers_list = (
self.slb_factory.create('ArrayOfStringSequence'))
for member in pool['members']:
real_servers_list.StringSequence.append(member)
real_server_group.realServers = real_servers_list
(self.slb_service.createRealServerGroups(server_group_list))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def _update_real_server_properties(self, new_member):
try:
address = new_member['address']
new_weight = new_member.get('weight')
rs_server = self._adx_server(address)
reply = (self.slb_service.getRealServerConfiguration(rs_server))
rs_conf_seq = (self.slb_factory.create(
'ArrayOfRealServerConfigurationSequence'))
reply.rsConfig.leastConnectionWeight = new_weight
# Work Around to fix bug in WSDL
reply.rsConfig.byteRateThresold = None
rs_conf_list = list()
rs_conf_list.append(reply.rsConfig)
rs_conf_seq.RealServerConfigurationSequence = rs_conf_list
(self.slb_service.setRealServersConfiguration(rs_conf_seq))
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def ifconfig_e1(self, ip_address, cidr):
# Configure route only on e1
try:
(network, mask) = cidr.split('/')
ifconfig = self.net_factory.create('InterfaceConfig')
ifconfig.id.interfaceType = 'ETHERNET'
ifconfig.id.portString = '1'
ifconfig.isRouteOnly = True
interface_config_seq = self.net_factory.create(
'ArrayOfInterfaceConfigSequence')
interface_config_seq.InterfaceConfigSequence.append(ifconfig)
self.net_service.setInterfaceConfig(interface_config_seq)
# Configure ip address on e1
ifid = self.net_factory.create('InterfaceID')
ipaddr_seq = (
self.net_factory.create('ArrayOfInterfaceIPAddressSequence'))
ipaddr = self.net_factory.create('InterfaceIPAddress')
ifid.portString = '1'
ifid.interfaceType = 'ETHERNET'
ipaddr.ip = ip_address
ipaddr.subnetMaskLength = mask
ipaddr_seq.InterfaceIPAddressSequence.append(ipaddr)
# Sending operations to the vLb
self.net_service.setInterfaceConfig(interface_config_seq)
self.net_service.addIPsToInterface(ifid, ipaddr_seq)
except suds.WebFault as e:
LOG.debug('Exception configuring e1 %s', e)
raise adx_exception.ConfigError(msg=e.message)
def unbind_member_from_vip(self, member, vip):
rs_ip_address = member['address']
rs_name = rs_ip_address
rs_name = member.get('name', rs_ip_address)
rs_port = member['protocol_port']
vs_ip_address = vip['address']
vs_port = vip['protocol_port']
vs_name = vip['name']
try:
vs_server_port = self._adx_server_port(vs_ip_address, vs_port,
vs_name)
rs_server_port = self._adx_server_port(rs_ip_address, rs_port,
rs_name)
(self.slb_service.unbindRealServerPortFromVipPort(
vs_server_port, rs_server_port))
# Need to check alternate solutions rather than sleep
# Is 5 seconds good enough ?
time.sleep(5)
except suds.WebFault as e:
raise adx_exception.ConfigError(msg=e.message)
def write_mem(self):
try:
self.sys_service.writeConfig()
except Exception as e:
raise adx_exception.ConfigError(msg=e.message)
