def execute(self, listeners, health_mon, vthunder):
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', {})
try:
self.axapi_client.slb.hm.create(health_mon.id[0:5],
openstack_mappings.hm_type(self.axapi_client,
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, axapi_args=args)
LOG.debug("Health Monitor created successfully: %s", health_mon.id)
except Exception as e:
LOG.exception("Failed to create Health Monitor: %s", str(e))
raise
try:
self.axapi_client.slb.service_group.update(health_mon.pool_id,
health_monitor=health_mon.id[0:5],
health_check_disable=0)
LOG.debug("Health Monitor %s is associated to pool %s successfully.",
health_mon.id, health_mon.pool_id)
except Exception as e:
LOG.exception("Failed to associate pool to Health Monitor: %s", str(e))
raise
def execute(self, member, vthunder, pool):
server_args = utils.meta(member, 'server', {})
server_args['conn-limit'] = CONF.server.conn_limit
server_args['conn-resume'] = CONF.server.conn_resume
server_args = {'server': server_args}
server_temp = {}
server_temp['template-server'] = CONF.server.template_server
if not member.enabled:
status = False
else:
status = True
try:
self.axapi_client.slb.server.create(member.id,
member.ip_address,
status=status,
server_templates=server_temp,
axapi_args=server_args)
LOG.debug("Member created successfully: %s", member.id)
except Exception as e:
LOG.exception("Failed to create member: %s", str(e))
raise
try:
self.axapi_client.slb.service_group.member.create(
pool.id, member.id, member.protocol_port)
LOG.debug("Member %s associated to pool %s successfully",
member.id, pool.id)
except Exception as e:
LOG.exception("Failed to associate member to pool: %s", str(e))
raise
def execute(self, listeners, health_mon, vthunder, update_dict):
""" Execute update health monitor """
# TODO(hthompson6) Length of name of healthmonitor for older vThunder devices
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', {})
try:
self.axapi_client.slb.hm.update(health_mon.id,
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,
port=listeners[0].protocol_port,
axapi_args=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):
server_name = '{}_{}'.format(member.project_id[:5],
member.ip_address.replace('.', '_'))
server_args = utils.meta(member, 'server', {})
server_args['conn-limit'] = CONF.server.conn_limit
server_args['conn-resume'] = CONF.server.conn_resume
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:
self.axapi_client.slb.server.replace(server_name,
member.ip_address,
status=status,
server_templates=server_temp,
axapi_args=server_args)
LOG.debug("Successfully updated member: %s", member.id)
except (acos_errors.ACOSException, exceptions.ConnectionError) as e:
LOG.exception("Failed to update member: %s", member.id)
raise e
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 set(self, set_method, loadbalancer):
status = self.axapi_client.slb.UP
if not loadbalancer.provisioning_status:
status = self.axapi_client.slb.DOWN
vip_meta = utils.meta(loadbalancer, 'virtual_server', {})
arp_disable = CONF.slb.arp_disable
vrid = CONF.slb.default_virtual_server_vrid
set_method(loadbalancer.id,
loadbalancer.vip.ip_address,
arp_disable=arp_disable,
status=status,
vrid=vrid,
axapi_body=vip_meta)
def set(self, set_method, pool):
axapi_args = {'service_group': utils.meta(pool, 'service_group', {})}
service_group_temp = {}
service_group_temp['template-server'] = CONF.service_group.template_server
service_group_temp['template-port'] = CONF.service_group.template_port
service_group_temp['template-policy'] = CONF.service_group.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)
set_method(pool.id,
protocol=protocol,
lb_method=lb_method,
service_group_templates=service_group_temp,
axapi_args=axapi_args)
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 set(self, set_method, loadbalancer):
status = self.axapi_client.slb.UP
if not loadbalancer.provisioning_status:
status = self.axapi_client.slb.DOWN
vip_meta = utils.meta(loadbalancer, 'virtual_server', {})
arp_disable = CONF.slb.arp_disable
vrid = CONF.slb.default_virtual_server_vrid
try:
set_method(loadbalancer.id,
loadbalancer.vip.ip_address,
arp_disable=arp_disable,
status=status,
vrid=vrid,
axapi_body=vip_meta)
LOG.debug("LoadBalancer created/updated succesfully: %s",
loadbalancer.id)
except Exception as e:
LOG.exception("Failed to create/update load balancer: %s", str(e))
raise
def set(self, set_method, pool, vthunder, **kwargs):
axapi_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)
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'),
axapi_args=axapi_args)
def execute(self, listeners, health_mon, vthunder):
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', {})
try:
self.axapi_client.slb.hm.create(health_mon.id,
openstack_mappings.hm_type(
self.axapi_client,
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,
axapi_args=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 execute(self, member, vthunder):
server_args = utils.meta(member, 'server', {})
server_args['conn-limit'] = CONF.server.conn_limit
server_args['conn-resume'] = CONF.server.conn_resume
server_args = {'server': server_args}
server_temp = {}
server_temp['template-server'] = CONF.server.template_server
if not member.enabled:
status = False
else:
status = True
try:
self.axapi_client.slb.server.update(member.id,
member.ip_address,
status=status,
server_templates=server_temp,
axapi_args=server_args)
LOG.debug("Member updated successfully: %s", member.id)
except Exception as e:
LOG.exception("Failed to update member: %s", str(e))
raise
def set(self, set_method, loadbalancer, **kwargs):
status = self.axapi_client.slb.UP
if not loadbalancer.provisioning_status:
status = self.axapi_client.slb.DOWN
vip_meta = utils.meta(loadbalancer, 'virtual_server', {})
arp_disable = CONF.slb.arp_disable
vrid = CONF.slb.default_virtual_server_vrid
desc = loadbalancer.description
if not desc:
desc = None
elif str(desc).isspace() or not str(desc):
desc = ""
else:
desc = '"{}"'.format(desc)
set_method(loadbalancer.id,
loadbalancer.vip.ip_address,
arp_disable=arp_disable,
description=desc,
status=status,
vrid=vrid,
port_list=kwargs.get('port_list'),
axapi_body=vip_meta)
from a10_octavia.common import config_options
from a10_octavia.common.data_models import VThunder
from a10_octavia.controller.worker.tasks import health_monitor_tasks as task
from a10_octavia.controller.worker.tasks import utils
from a10_octavia.tests.common import a10constants
from a10_octavia.tests.unit.base import BaseTaskTestCase
VTHUNDER = VThunder()
HM = o_data_models.HealthMonitor(id=a10constants.MOCK_HM_ID,
type='TCP',
delay=7,
timeout=3,
rise_threshold=8,
http_method='GET')
ARGS = utils.meta(HM, 'hm', {})
LISTENERS = [
o_data_models.Listener(id=a10constants.MOCK_LISTENER_ID,
protocol_port=mock.ANY)
]
FLAVOR_ARGS = {
'monitor': {
'retry': 5,
'method': {
'http': {
'http_response_code': '201'
}
},
}
}
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
from oslo_config import fixture as oslo_fixture
from octavia.common import constants as o_constants
from octavia.common import data_models as o_data_models
from octavia.common import exceptions
from a10_octavia.common import config_options
from a10_octavia.common import data_models
import a10_octavia.controller.worker.tasks.service_group_tasks as task
from a10_octavia.controller.worker.tasks import utils
from a10_octavia.tests.common import a10constants
from a10_octavia.tests.unit.base import BaseTaskTestCase
VTHUNDER = data_models.VThunder()
POOL = o_data_models.Pool(id=a10constants.MOCK_POOL_ID, name="sg1")
AXAPI_ARGS = {'service_group': utils.meta(POOL, 'service_group', {})}
class TestHandlerServiceGroupTasks(BaseTaskTestCase):
def setUp(self):
super(TestHandlerServiceGroupTasks, self).setUp()
imp.reload(task)
self.client_mock = mock.Mock()
self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
self.conf.register_opts(config_options.A10_SERVICE_GROUP_OPTS,
group=a10constants.SERVICE_GROUP_CONF_SECTION)
self.conf.register_opts(config_options.A10_GLOBAL_OPTS,
group=a10constants.A10_GLOBAL_CONF_SECTION)
def tearDown(self):
super(TestHandlerServiceGroupTasks, self).tearDown()
from a10_octavia.common import config_options
from a10_octavia.common import data_models
import a10_octavia.controller.worker.tasks.server_tasks as task
from a10_octavia.controller.worker.tasks import utils
from a10_octavia.tests.common import a10constants
from a10_octavia.tests.unit import base
VTHUNDER = data_models.VThunder()
POOL = o_data_models.Pool(id=a10constants.MOCK_POOL_ID,
protocol=a10constants.MOCK_SERVICE_GROUP_PROTOCOL)
MEMBER = o_data_models.Member(
id=a10constants.MOCK_MEMBER_ID, protocol_port=t_constants.MOCK_PORT_ID,
project_id=t_constants.MOCK_PROJECT_ID, ip_address=t_constants.MOCK_IP_ADDRESS,
subnet_id=a10constants.MOCK_SUBNET_ID)
KEY_ARGS = {'server': utils.meta(MEMBER, 'server', {'conn_resume': None, 'conn_limit': 64000000})}
SERVER_NAME = '{}_{}'.format(MEMBER.project_id[:5],
MEMBER.ip_address.replace('.', '_'))
class TestHandlerServerTasks(base.BaseTaskTestCase):
def setUp(self):
super(TestHandlerServerTasks, self).setUp()
imp.reload(task)
self.client_mock = mock.Mock()
self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
self.conf.register_opts(config_options.A10_SERVER_OPTS,
group=a10constants.SERVER_CONF_SECTION)
self.conf.register_opts(config_options.A10_GLOBAL_OPTS,
group=a10constants.A10_GLOBAL_CONF_SECTION)
from a10_octavia.controller.worker.tasks import utils
from a10_octavia.tests.common import a10constants
from a10_octavia.tests.unit import base
VTHUNDER = data_models.VThunder()
POOL = o_data_models.Pool(id=a10constants.MOCK_POOL_ID,
protocol=a10constants.MOCK_SERVICE_GROUP_PROTOCOL)
MEMBER = o_data_models.Member(id=a10constants.MOCK_MEMBER_ID,
protocol_port=t_constants.MOCK_PORT_ID,
project_id=t_constants.MOCK_PROJECT_ID,
ip_address=t_constants.MOCK_IP_ADDRESS)
AXAPI_ARGS = {
'server':
utils.meta(MEMBER, 'server', {
'conn-resume': None,
'conn-limit': 64000000
})
}
SERVER_NAME = '{}_{}'.format(MEMBER.project_id[:5],
MEMBER.ip_address.replace('.', '_'))
class TestHandlerServerTasks(base.BaseTaskTestCase):
def setUp(self):
super(TestHandlerServerTasks, self).setUp()
imp.reload(task)
self.client_mock = mock.Mock()
self.conf = self.useFixture(oslo_fixture.Config(cfg.CONF))
self.conf.register_opts(config_options.A10_SERVER_OPTS,
group=a10constants.SERVER_CONF_SECTION)
self.conf.register_opts(config_options.A10_GLOBAL_OPTS,
