def set(self, set_method, loadbalancer, flavor_data=None, **kwargs):
config_args = {
'arp_disable': CONF.slb.arp_disable,
'port_list': kwargs.get('port_list'),
'vrid': CONF.slb.default_virtual_server_vrid,
'virtual_server': utils.meta(loadbalancer, 'virtual_server', {})
}
status = self.axapi_client.slb.UP
if not loadbalancer.provisioning_status:
status = self.axapi_client.slb.DOWN
config_args['status'] = status
desc = loadbalancer.description
if not desc:
desc = None
elif str(desc).isspace() or not str(desc):
desc = ""
else:
desc = '"{}"'.format(desc)
config_args['description'] = desc
if flavor_data:
virtual_server_flavor = flavor_data.get('virtual_server')
if virtual_server_flavor:
name_exprs = virtual_server_flavor.get('name_expressions')
if name_exprs:
del virtual_server_flavor['name_expressions']
virtual_server_flavor.update(
utils.parse_name_expressions(loadbalancer.name,
name_exprs))
config_args['virtual_server'].update(virtual_server_flavor)
set_method(loadbalancer.id, loadbalancer.vip.ip_address, **config_args)
def set(self, set_method, pool, vthunder, flavor=None, **kwargs):
pool_args = {'service_group': utils.meta(pool, 'service_group', {})}
device_templates = self.axapi_client.slb.template.templates.get()
service_group_temp = {}
template_server = CONF.service_group.template_server
if template_server and template_server.lower() != 'none':
if CONF.a10_global.use_shared_for_template_lookup:
LOG.warning(
'Shared partition template lookup for `[service_group]`'
' is not supported on template `template-server`')
service_group_temp['template-server'] = template_server
template_port = CONF.service_group.template_port
if template_port and template_port.lower() != 'none':
if CONF.a10_global.use_shared_for_template_lookup:
LOG.warning(
'Shared partition template lookup for `[service_group]`'
' is not supported on template `template-port`')
service_group_temp['template-port'] = template_port
template_policy = CONF.service_group.template_policy
if template_policy and template_policy.lower() != 'none':
template_key = 'template-policy'
if vthunder.partition_name != "shared":
if CONF.a10_global.use_shared_for_template_lookup:
template_key = utils.shared_template_modifier(
template_key, template_policy, device_templates)
service_group_temp[template_key] = template_policy
protocol = openstack_mappings.service_group_protocol(
self.axapi_client, pool.protocol)
lb_method = openstack_mappings.service_group_lb_method(
self.axapi_client, pool.lb_algorithm)
# Handle options from flavor
if flavor:
pool_flavor = flavor.get('service_group')
if pool_flavor:
name_exprs = pool_flavor.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(
pool.name, name_exprs)
pool_flavor.pop('name_expressions', None)
pool_args['service_group'].update(pool_flavor)
pool_args['service_group'].update(parsed_exprs)
set_method(pool.id,
protocol=protocol,
lb_method=lb_method,
service_group_templates=service_group_temp,
mem_list=kwargs.get('mem_list'),
hm_name=kwargs.get('health_monitor'),
**pool_args)
def execute(self, member, vthunder, pool, member_count_ip, flavor=None):
server_name = '{}_{}'.format(member.project_id[:5], member.ip_address.replace('.', '_'))
server_args = utils.meta(member, 'server', {})
server_args = utils.dash_to_underscore(server_args)
server_args['conn_limit'] = CONF.server.conn_limit
server_args['conn_resume'] = CONF.server.conn_resume
# overwrite options from flavor
if flavor:
server_flavor = flavor.get('server')
if server_flavor:
name_exprs = server_flavor.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(member.name, name_exprs)
server_flavor.pop('name_expressions', None)
server_args.update(server_flavor)
server_args.update(parsed_exprs)
server_args = {'server': server_args}
server_temp = {}
template_server = CONF.server.template_server
if template_server and template_server.lower() != 'none':
if CONF.a10_global.use_shared_for_template_lookup:
LOG.warning('Shared partition template lookup for `[server]`'
' is not supported on template `template-server`')
server_temp = {'template-server': template_server}
if not member.enabled:
status = False
else:
status = True
try:
try:
self.axapi_client.slb.server.create(server_name, member.ip_address, status=status,
server_templates=server_temp,
**server_args)
LOG.debug("Successfully created member: %s", member.id)
except (acos_errors.Exists, acos_errors.AddressSpecifiedIsInUse):
self.axapi_client.slb.server.update(server_name, member.ip_address, status=status,
server_templates=server_temp,
**server_args)
except (acos_errors.ACOSException, exceptions.ConnectionError) as e:
LOG.exception("Failed to create member: %s", member.id)
raise e
try:
self.axapi_client.slb.service_group.member.create(
pool.id, server_name, member.protocol_port)
LOG.debug("Successfully associated member %s to pool %s",
member.id, pool.id)
except (acos_errors.ACOSException, exceptions.ConnectionError) as e:
LOG.exception("Failed to associate member %s to pool %s",
member.id, pool.id)
raise e
def execute(self,
listeners,
health_mon,
vthunder,
update_dict,
flavor=None):
""" Execute update health monitor """
health_mon.update(update_dict)
method = None
url = None
expect_code = None
if health_mon.type in a10constants.HTTP_TYPE:
method = health_mon.http_method
url = health_mon.url_path
expect_code = health_mon.expected_codes
args = utils.meta(health_mon, 'hm', {})
args = utils.dash_to_underscore(args)
# overwrite options from flavor
if flavor:
flavors = flavor.get('health_monitor')
if flavors:
name_exprs = flavors.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(
health_mon.name, name_exprs)
flavors.pop('name_expressions', None)
flavors.update(parsed_exprs)
args.update({'monitor': flavors})
try:
hm_name = _get_hm_name(self.axapi_client, health_mon)
post_data = CONF.health_monitor.post_data
self.axapi_client.slb.hm.update(hm_name,
openstack_mappings.hm_type(
self.axapi_client,
health_mon.type),
health_mon.delay,
health_mon.timeout,
health_mon.rise_threshold,
method=method,
url=url,
expect_code=expect_code,
post_data=post_data,
port=listeners[0].protocol_port,
**args)
LOG.debug("Successfully updated health monitor: %s", health_mon.id)
except (acos_errors.ACOSException, ConnectionError) as e:
LOG.exception("Failed to update health monitor: %s", health_mon.id)
raise e
def execute(self, member, vthunder, pool, flavor=None, update_dict={}):
member.__dict__.update(update_dict)
server_args = utils.meta(member, 'server', {})
server_args = utils.dash_to_underscore(server_args)
server_args['conn_limit'] = CONF.server.conn_limit
server_args['conn_resume'] = CONF.server.conn_resume
# overwrite options from flavor
if flavor:
server_flavor = flavor.get('server')
if server_flavor:
name_exprs = server_flavor.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(
member.name, name_exprs)
server_flavor.pop('name_expressions', None)
server_args.update(server_flavor)
server_args.update(parsed_exprs)
server_args = {'server': server_args}
template_server = CONF.server.template_server
if template_server and template_server.lower() == 'none':
template_server = None
server_temp = {'template-server': template_server}
if not member.enabled:
status = False
else:
status = True
try:
server_name = _get_server_name(self.axapi_client, member)
port_list = self.axapi_client.slb.server.get(
server_name)['server'].get('port-list')
self.axapi_client.slb.server.replace(server_name,
member.ip_address,
status=status,
server_templates=server_temp,
port_list=port_list,
**server_args)
LOG.debug("Successfully updated member: %s", member.id)
except acos_errors.NotFound:
LOG.debug("Unable to find member %s in pool %s", member.id,
pool.id)
except (acos_errors.ACOSException, exceptions.ConnectionError) as e:
LOG.exception("Failed to update member: %s", member.id)
raise e
def execute(self, listeners, health_mon, vthunder, flavor=None):
method = None
url = None
expect_code = None
if health_mon.type in a10constants.HTTP_TYPE:
method = health_mon.http_method
url = health_mon.url_path
expect_code = health_mon.expected_codes
args = utils.meta(health_mon, 'hm', {})
args = utils.dash_to_underscore(args)
# overwrite options from flavor
if flavor:
flavors = flavor.get('health_monitor')
if flavors:
name_exprs = flavors.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(
health_mon.name, name_exprs)
flavors.pop('name_expressions', None)
flavors.update(parsed_exprs)
args.update({'monitor': flavors})
try:
health_mon.type = openstack_mappings.hm_type(
self.axapi_client, health_mon.type)
except Exception:
raise exceptions.ProviderUnsupportedOptionError(
prov="A10",
user_msg=("Failed to create health monitor {}, "
"A health monitor of type {} is not supported "
"by A10 provider").format(health_mon.id,
health_mon.type))
try:
post_data = CONF.health_monitor.post_data
self.axapi_client.slb.hm.create(health_mon.id,
health_mon.type,
health_mon.delay,
health_mon.timeout,
health_mon.rise_threshold,
method=method,
port=listeners[0].protocol_port,
url=url,
expect_code=expect_code,
post_data=post_data,
**args)
LOG.debug("Successfully created health monitor: %s", health_mon.id)
except (acos_errors.ACOSException, ConnectionError) as e:
LOG.exception("Failed to create health monitor: %s", health_mon.id)
raise e
try:
self.axapi_client.slb.service_group.update(health_mon.pool_id,
hm_name=health_mon.id,
health_check_disable=0)
LOG.debug("Successfully associated health monitor %s to pool %s",
health_mon.id, health_mon.pool_id)
except (acos_errors.ACOSException, ConnectionError) as e:
LOG.exception("Failed to associate health monitor %s to pool %s",
health_mon.id, health_mon.pool_id)
raise e
def test_parse_name_expressions_with_no_name_specified(self):
expect_result = {}
obj_flavor = utils.parse_name_expressions(None, NAME_EXPRESSIONS)
self.assertEqual(expect_result, obj_flavor)
def test_parse_name_expressions(self):
expect_result = {"support_http2": 1}
obj_flavor = utils.parse_name_expressions("vport1", NAME_EXPRESSIONS)
self.assertEqual(expect_result, obj_flavor)
def set(self,
set_method,
loadbalancer,
listener,
vthunder,
flavor_data=None,
update_dict=None,
ssl_template=None):
listener.load_balancer = loadbalancer
listener.protocol = openstack_mappings.virtual_port_protocol(
self.axapi_client, listener.protocol).lower()
config_data = {
'ipinip': CONF.listener.ipinip,
'use_rcv_hop': CONF.listener.use_rcv_hop_for_resp,
'ha_conn_mirror': CONF.listener.ha_conn_mirror
}
status = self.axapi_client.slb.UP
if not listener.enabled:
status = self.axapi_client.slb.DOWN
config_data['status'] = status
conn_limit = CONF.listener.conn_limit
if listener.connection_limit != -1:
conn_limit = listener.connection_limit
if conn_limit < 1 or conn_limit > 64000000:
raise Exception('The specified member server connection limit '
'(configuration setting: conn-limit) is out of '
'bounds with value {0}. Please set to between '
'1-64000000.'.format(conn_limit))
config_data['conn_limit'] = conn_limit
no_dest_nat = CONF.listener.no_dest_nat
if no_dest_nat and (
listener.protocol
not in a10constants.NO_DEST_NAT_SUPPORTED_PROTOCOL):
LOG.warning("'no_dest_nat' is not allowed for HTTP," +
"HTTPS or TERMINATED_HTTPS listener.")
no_dest_nat = False
config_data['no_dest_nat'] = no_dest_nat
autosnat = CONF.listener.autosnat
if autosnat and no_dest_nat:
raise exceptions.SNATConfigurationError()
config_data['autosnat'] = autosnat
c_pers, s_pers = utils.get_sess_pers_templates(listener.default_pool)
device_templates = self.axapi_client.slb.template.templates.get()
vport_templates = {}
template_vport = CONF.listener.template_virtual_port
if template_vport and template_vport.lower() != 'none':
template_key = 'template-virtual-port'
if vthunder.partition_name != "shared":
if CONF.a10_global.use_shared_for_template_lookup:
template_key = utils.shared_template_modifier(
template_key, template_vport, device_templates)
vport_templates[template_key] = template_vport
template_args = {}
if listener.protocol.upper() in a10constants.HTTP_TYPE:
if listener.protocol == 'https' and listener.tls_certificate_id:
# Adding TERMINATED_HTTPS SSL cert, created in previous task
template_args["template_client_ssl"] = listener.id
if (update_dict and 'default_tls_container_ref' in update_dict
and update_dict["default_tls_container_ref"] is None):
template_args["template_client_ssl"] = None
elif listener.protocol == 'https':
template_args["template_client_ssl"] = listener.id
template_http = CONF.listener.template_http
if template_http and template_http.lower() != 'none':
template_key = 'template-http'
if vthunder.partition_name != "shared":
if CONF.a10_global.use_shared_for_template_lookup:
template_key = utils.shared_template_modifier(
template_key, template_http, device_templates)
vport_templates[template_key] = template_http
"""
if ha_conn_mirror is not None:
ha_conn_mirror = None
LOG.warning("'ha_conn_mirror' is not allowed for HTTP "
"or TERMINATED_HTTPS listeners.")
"""
elif listener.protocol == 'tcp':
template_tcp = CONF.listener.template_tcp
if template_tcp and template_tcp.lower() != 'none':
template_key = 'template-tcp'
if vthunder.partition_name != "shared":
if CONF.a10_global.use_shared_for_template_lookup:
template_key = utils.shared_template_modifier(
template_key, template_tcp, device_templates)
vport_templates[template_key] = template_tcp
template_policy = CONF.listener.template_policy
if template_policy and template_policy.lower() != 'none':
template_key = 'template-policy'
if vthunder.partition_name != "shared":
if CONF.a10_global.use_shared_for_template_lookup:
template_key = utils.shared_template_modifier(
template_key, template_policy, device_templates)
vport_templates[template_key] = template_policy
vport_args = {}
if flavor_data:
virtual_port_flavor = flavor_data.get('virtual_port')
if virtual_port_flavor:
name_exprs = virtual_port_flavor.get('name_expressions')
parsed_exprs = utils.parse_name_expressions(
listener.name, name_exprs)
virtual_port_flavor.pop('name_expressions', None)
virtual_port_flavor.update(parsed_exprs)
vport_args = {'port': virtual_port_flavor}
# use default nat-pool pool if pool is not specified
if 'port' not in vport_args or 'pool' not in vport_args['port']:
pool_flavor = flavor_data.get('nat_pool')
if pool_flavor and 'pool_name' in pool_flavor:
pool_arg = {}
pool_arg['pool'] = pool_flavor['pool_name']
if 'port' in vport_args:
vport_args['port'].update(pool_arg)
else:
vport_args['port'] = pool_arg
config_data.update(template_args)
config_data.update(vport_args)
set_method(loadbalancer.id,
listener.id,
listener.protocol,
listener.protocol_port,
listener.default_pool_id,
s_pers_name=s_pers,
c_pers_name=c_pers,
virtual_port_templates=vport_templates,
**config_data)
listener.protocol = listener.protocol.upper()
