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()