Use oslo-config-generator

To generate the sample config file, do what other OpenStack projects do
and use the oslo.config provided mechanism.

Story: 2001009
Task:  4201

Change-Id: I490de4110843f7dfd618a6a8cc8d6a4e35db65ce
This commit is contained in:
Adrian Czarnecki 2017-05-02 15:56:11 +02:00
parent 97a9a7032a
commit 5f168778c6
21 changed files with 584 additions and 208 deletions

3
.gitignore vendored
View File

@ -11,4 +11,5 @@ virtenv/*
cover/
.tox/
*egg-info/
.testrepository/
.testrepository/
*.sample

View File

@ -0,0 +1,7 @@
# config-generator
To generate sample configuration execute
```sh
tox -e genconfig
```

View File

@ -0,0 +1,6 @@
[DEFAULT]
output_file = etc/monasca/persister.conf.sample
wrap_width = 90
format = ini
namespace = monasca_persister
namespace = oslo.log

View File

@ -1,65 +0,0 @@
[DEFAULT]
log_config_append=/etc/monasca/persister-logging.conf
[repositories]
# The driver to use for the metrics repository
metrics_driver = monasca_persister.repositories.influxdb.metrics_repository:MetricInfluxdbRepository
#metrics_driver = monasca_persister.repositories.cassandra.metrics_repository:MetricCassandraRepository
# The driver to use for the alarm state history repository
alarm_state_history_driver = monasca_persister.repositories.influxdb.alarm_state_history_repository:AlarmStateHistInfluxdbRepository
#alarm_state_history_driver = monasca_persister.repositories.cassandra.alarm_state_history_repository:AlarmStateHistCassandraRepository
[zookeeper]
# Comma separated list of host:port
uri = 192.168.10.4:2181
partition_interval_recheck_seconds = 15
[kafka_alarm_history]
# Comma separated list of Kafka broker host:port.
uri = 192.168.10.4:9092
group_id = 1_alarm-state-transitions
topic = alarm-state-transitions
consumer_id = 1
client_id = 1
database_batch_size = 1000
max_wait_time_seconds = 30
# The following 3 values are set to the kakfa-python defaults
fetch_size_bytes = 4096
buffer_size = 4096
# 8 times buffer size
max_buffer_size = 32768
# Path in zookeeper for kafka consumer group partitioning algo
zookeeper_path = /persister_partitions/alarm-state-transitions
num_processors = 1
[kafka_metrics]
# Comma separated list of Kafka broker host:port
uri = 192.168.10.4:9092
group_id = 1_metrics
topic = metrics
consumer_id = 1
client_id = 1
database_batch_size = 1000
max_wait_time_seconds = 30
# The following 3 values are set to the kakfa-python defaults
fetch_size_bytes = 4096
buffer_size = 4096
# 8 times buffer size
max_buffer_size = 32768
# Path in zookeeper for kafka consumer group partitioning algo
zookeeper_path = /persister_partitions/metrics
num_processors = 1
[influxdb]
database_name = mon
ip_address = 192.168.10.4
port = 8086
user = mon_persister
password = password
# Uncomment, set cluster_ip_addresses, and change the repositories to point to the cassandra classes
#[cassandra]
# Comma separated list of Cassandra node IP addresses. No spaces.
#cluster_ip_addresses: 192.168.10.6
#keyspace: monasca

View File

@ -0,0 +1,74 @@
# Copyright 2017 FUJITSU LIMITED
#
# 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.
import os
import pkgutil
from oslo_config import cfg
from oslo_utils import importutils
CONF = cfg.CONF
def load_conf_modules():
"""Load all modules that contain configuration.
Method iterates over modules of :py:module:`monasca_persister.conf`
and imports only those that contain following methods:
- list_opts (required by oslo_config.genconfig)
- register_opts (required by :py:currentmodule:)
"""
for modname in _list_module_names():
mod = importutils.import_module('monasca_persister.conf.' + modname)
required_funcs = ['register_opts', 'list_opts']
for func in required_funcs:
if hasattr(mod, func):
yield mod
def _list_module_names():
module_names = []
package_path = os.path.dirname(os.path.abspath(__file__))
for _, modname, ispkg in pkgutil.iter_modules(path=[package_path]):
if not (modname == "opts" and ispkg):
module_names.append(modname)
return module_names
def register_opts():
"""Register all conf modules opts.
This method allows different modules to register
opts according to their needs.
"""
for mod in load_conf_modules():
mod.register_opts(cfg.CONF)
def list_opts():
"""List all conf modules opts.
Goes through all conf modules and yields their opts.
"""
for mod in load_conf_modules():
mod_opts = mod.list_opts()
if type(mod_opts) is list:
for single_mod_opts in mod_opts:
yield single_mod_opts[0], single_mod_opts[1]
else:
yield mod_opts[0], mod_opts[1]

View File

@ -0,0 +1,37 @@
# (C) Copyright 2016 Hewlett Packard Enterprise Development Company LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
cassandra_opts = [
cfg.ListOpt('cluster_ip_addresses',
help='Comma separated list of Cassandra node IP addresses',
default=['127.0.0.1'],
item_type=cfg.IPOpt),
cfg.StrOpt('keyspace',
help='keyspace where metric are stored',
default='monasca')]
cassandra_group = cfg.OptGroup(name='cassandra')
def register_opts(conf):
conf.register_group(cassandra_group)
conf.register_opts(cassandra_opts, cassandra_group)
def list_opts():
return cassandra_group, cassandra_opts

View File

@ -0,0 +1,45 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
influxdb_opts = [
cfg.StrOpt('database_name',
help='database name where metrics are stored',
default='mon'),
cfg.IPOpt('ip_address',
help='ip address to influxdb'),
cfg.PortOpt('port',
help='port to influxdb',
default=8086),
cfg.StrOpt('user',
help='influxdb user ',
default='mon_persister'),
cfg.StrOpt('password',
secret=True,
help='influxdb password')]
influxdb_group = cfg.OptGroup(name='influxdb',
title='influxdb')
def register_opts(conf):
conf.register_group(influxdb_group)
conf.register_opts(influxdb_opts, influxdb_group)
def list_opts():
return influxdb_group, influxdb_opts

View File

@ -0,0 +1,57 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
import copy
from oslo_config import cfg
from monasca_persister.conf import kafka_common
from monasca_persister.conf import types
kafka_alarm_history_group = cfg.OptGroup(name='kafka_alarm_history',
title='kafka_alarm_history')
kafka_alarm_history_opts = [
# NOTE(czarneckia) default by reference does not work with ListOpt
cfg.ListOpt('uri',
help='Comma separated list of Kafka broker host:port',
default=['127.0.0.1:9092'],
item_type=types.HostAddressPortType()),
cfg.StrOpt('group_id',
help='Kafka Group from which persister get data',
default='1_alarm-state-transitions'),
cfg.StrOpt('topic',
help='Kafka Topic from which persister get data',
default='alarm-state-transitions'),
cfg.StrOpt('zookeeper_path',
help='Path in zookeeper for kafka consumer group partitioning algorithm',
default='/persister_partitions/$kafka_alarm_history.topic')
]
# Replace Default OPt with reference to kafka group option
kafka_common_opts = copy.deepcopy(kafka_common.kafka_common_opts)
for opt in kafka_common_opts:
opt.default = '$kafka.{}'.format(opt.name)
def register_opts(conf):
conf.register_group(kafka_alarm_history_group)
conf.register_opts(kafka_alarm_history_opts + kafka_common_opts,
kafka_alarm_history_group)
def list_opts():
return kafka_alarm_history_group, kafka_alarm_history_opts

View File

@ -0,0 +1,60 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
kafka_common_opts = [
cfg.StrOpt('consumer_id',
help='Name/id of persister kafka consumer',
advanced=True,
default='monasca-persister'),
cfg.StrOpt('client_id',
help='id of persister kafka client',
advanced=True,
default='monasca-persister'),
cfg.IntOpt('database_batch_size',
help='Maximum number of metric to buffer before writing to database',
default=1000),
cfg.IntOpt('max_wait_time_seconds',
help='Maximum wait time for write batch to database',
default=30),
cfg.IntOpt('fetch_size_bytes',
help='Fetch size, in bytes. This value is set to the kafka-python defaults',
default=4096),
cfg.IntOpt('buffer_size',
help='Buffer size, in bytes. This value is set to the kafka-python defaults',
default='$kafka.fetch_size_bytes'),
cfg.IntOpt('max_buffer_size',
help='Maximum buffer size, in bytes, default value is 8 time buffer_size.'
'This value is set to the kafka-python defaults. ',
default=32768),
cfg.IntOpt('num_processors',
help='Number of processes spawned by persister',
default=0)
]
kafka_common_group = cfg.OptGroup(name='kafka',
title='kafka')
def register_opts(conf):
conf.register_group(kafka_common_group)
conf.register_opts(kafka_common_opts, kafka_common_group)
def list_opts():
return kafka_common_group, kafka_common_opts

View File

@ -0,0 +1,56 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
import copy
from oslo_config import cfg
from monasca_persister.conf import kafka_common
from monasca_persister.conf import types
kafka_metrics_group = cfg.OptGroup(name='kafka_metrics',
title='kafka_metrics')
kafka_metrics_opts = [
# NOTE(czarneckia) default by reference does not work with ListOpt
cfg.ListOpt('uri',
help='Comma separated list of Kafka broker host:port',
default=['127.0.0.1:9092'],
item_type=types.HostAddressPortType()),
cfg.StrOpt('group_id',
help='Kafka Group from which persister get data',
default='1_metrics'),
cfg.StrOpt('topic',
help='Kafka Topic from which persister get data',
default='metrics'),
cfg.StrOpt('zookeeper_path',
help='Path in zookeeper for kafka consumer group partitioning algorithm',
default='/persister_partitions/$kafka_metrics.topic'),
]
# Replace Default OPt with reference to kafka group option
kafka_common_opts = copy.deepcopy(kafka_common.kafka_common_opts)
for opt in kafka_common_opts:
opt.default = '$kafka.{}'.format(opt.name)
def register_opts(conf):
conf.register_group(kafka_metrics_group)
conf.register_opts(kafka_metrics_opts + kafka_common_opts,
kafka_metrics_group)
def list_opts():
return kafka_metrics_group, kafka_metrics_opts

View File

@ -0,0 +1,37 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
repositories_opts = [
cfg.StrOpt(name='metrics_driver',
help='The repository driver to use for metrics',
default='monasca_persister.repositories.influxdb.metrics_repository:MetricInfluxdbRepository'),
cfg.StrOpt(name='alarm_state_history_driver',
help='The repository driver to use for alarm state history',
default='monasca_persister.repositories.influxdb.metrics_repository:MetricInfluxdbRepository')]
repositories_group = cfg.OptGroup(name='repositories',
title='repositories')
def register_opts(conf):
conf.register_group(repositories_group)
conf.register_opts(repositories_opts, repositories_group)
def list_opts():
return repositories_group, repositories_opts

View File

@ -0,0 +1,58 @@
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
from oslo_config import types
class HostAddressPortOpt(cfg.Opt):
"""Option for HostAddressPortType.
Accept hostname or ip address with TCP/IP port number.
"""
def __init__(self, name, **kwargs):
ip_port_type = HostAddressPortType()
super(HostAddressPortOpt, self).__init__(name,
type=ip_port_type,
**kwargs)
class HostAddressPortType(types.HostAddress):
"""HostAddress with additional port."""
def __init__(self, version=None):
type_name = 'ip and port value'
super(HostAddressPortType, self).__init__(version, type_name=type_name)
def __call__(self, value):
addr, port = value.split(':')
addr = self.validate_addr(addr)
port = self._validate_port(port)
if not addr and not port:
raise ValueError('%s is not valid ip with optional port')
return '%s:%d' % (addr, port)
@staticmethod
def _validate_port(port):
return types.Port()(port)
def validate_addr(self, addr):
try:
addr = self.ip_address(addr)
except ValueError:
try:
addr = self.hostname(addr)
except ValueError:
raise ValueError("%s is not a valid host address", addr)
return addr

View File

@ -0,0 +1,39 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_config import cfg
from monasca_persister.conf import types
zookeeper_opts = [
cfg.ListOpt('uri',
help='Comma separated list of zookeper instance host:port',
default=['127.0.0.1:2181'],
item_type=types.HostAddressPortType()),
cfg.IntOpt('partition_interval_recheck_seconds',
help='Time between rechecking if partition is available',
default=15)]
zookeeper_group = cfg.OptGroup(name='zookeeper', title='zookeeper')
def register_opts(conf):
conf.register_group(zookeeper_group)
conf.register_opts(zookeeper_opts, zookeeper_group)
def list_opts():
return zookeeper_group, zookeeper_opts

View File

@ -0,0 +1,46 @@
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslo_log import log
from monasca_persister import conf
from monasca_persister import version
CONF = conf.CONF
LOG = log.getLogger(__name__)
_CONF_LOADED = False
def parse_args():
global _CONF_LOADED
if _CONF_LOADED:
LOG.debug('Configuration has been already loaded')
return
log.set_defaults()
log.register_options(CONF)
CONF(prog='persister',
project='monasca',
version=version.version_str,
description='Persists metrics & alarm history in TSDB')
log.setup(CONF,
product_name='persister',
version=version.version_str)
conf.register_opts()
_CONF_LOADED = True

View File

@ -1,4 +1,5 @@
# (C) Copyright 2014-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@ -31,51 +32,12 @@ from monasca_common.simport import simport
from oslo_config import cfg
from oslo_log import log
from monasca_persister import config
from monasca_persister.repositories import persister
from monasca_persister import version
LOG = log.getLogger(__name__)
zookeeper_opts = [cfg.StrOpt('uri'),
cfg.IntOpt('partition_interval_recheck_seconds')]
zookeeper_group = cfg.OptGroup(name='zookeeper', title='zookeeper')
cfg.CONF.register_group(zookeeper_group)
cfg.CONF.register_opts(zookeeper_opts, zookeeper_group)
kafka_common_opts = [cfg.StrOpt('uri'),
cfg.StrOpt('group_id'),
cfg.StrOpt('topic'),
cfg.StrOpt('consumer_id'),
cfg.StrOpt('client_id'),
cfg.IntOpt('database_batch_size'),
cfg.IntOpt('max_wait_time_seconds'),
cfg.IntOpt('fetch_size_bytes'),
cfg.IntOpt('buffer_size'),
cfg.IntOpt('max_buffer_size'),
cfg.StrOpt('zookeeper_path'),
cfg.IntOpt('num_processors')]
kafka_metrics_opts = kafka_common_opts
kafka_alarm_history_opts = kafka_common_opts
kafka_metrics_group = cfg.OptGroup(name='kafka_metrics', title='kafka_metrics')
kafka_alarm_history_group = cfg.OptGroup(name='kafka_alarm_history',
title='kafka_alarm_history')
cfg.CONF.register_group(kafka_metrics_group)
cfg.CONF.register_group(kafka_alarm_history_group)
cfg.CONF.register_opts(kafka_metrics_opts, kafka_metrics_group)
cfg.CONF.register_opts(kafka_alarm_history_opts, kafka_alarm_history_group)
repositories_opts = [
cfg.StrOpt('metrics_driver', help='The repository driver to use for metrics'),
cfg.StrOpt('alarm_state_history_driver', help='The repository driver to use for alarm state history')]
repositories_group = cfg.OptGroup(name='repositories', title='repositories')
cfg.CONF.register_group(repositories_group)
cfg.CONF.register_opts(repositories_opts, repositories_group)
processors = [] # global list to facilitate clean signal handling
exiting = False
@ -133,20 +95,10 @@ def start_process(respository, kafka_config):
m_persister.run()
def _init_config():
log.register_options(cfg.CONF)
log.set_defaults()
cfg.CONF(prog='persister',
project='monasca',
version=version.version_str,
description='Persists metrics & alarm history in TSDB')
log.setup(cfg.CONF, 'monasca-persister', version=version.version_str)
def main():
"""Start persister."""
_init_config()
config.parse_args()
metric_repository = simport.load(cfg.CONF.repositories.metrics_driver)
alarm_state_history_repository = simport.load(cfg.CONF.repositories.alarm_state_history_driver)

View File

@ -1,22 +0,0 @@
# (C) Copyright 2016 Hewlett Packard Enterprise Development Company LP
#
# 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.
from oslo_config import cfg
cassandra_opts = [cfg.StrOpt('cluster_ip_addresses'),
cfg.StrOpt('keyspace')]
cassandra_group = cfg.OptGroup(name='cassandra')
cfg.CONF.register_group(cassandra_group)
cfg.CONF.register_opts(cassandra_opts, cassandra_group)

View File

@ -1,25 +0,0 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
#
# 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.
from oslo_config import cfg
influxdb_opts = [cfg.StrOpt('database_name'),
cfg.StrOpt('ip_address'),
cfg.StrOpt('port'),
cfg.StrOpt('user'),
cfg.StrOpt('password', secret=True)]
influxdb_group = cfg.OptGroup(name='influxdb', title='influxdb')
cfg.CONF.register_group(influxdb_group)
cfg.CONF.register_opts(influxdb_opts, influxdb_group)

View File

@ -0,0 +1,47 @@
# (C) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
# Copyright 2017 FUJITSU LIMITED
#
# 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.
from oslotest import base
from monasca_persister.conf import types
class TestHostAddressPortType(base.BaseTestCase):
def setUp(self):
super(TestHostAddressPortType, self).setUp()
self.types = types.HostAddressPortType()
def test_ip_address(self):
self.assertEqual('127.0.0.1:2121', self.types('127.0.0.1:2121'))
def test_hostname(self):
self.assertEqual('localhost:2121', self.types('localhost:2121'))
# failure scenario
def test_missing_port(self):
self.assertRaises(ValueError, self.types, '127.0.0.1')
def test_missing_address(self):
self.assertRaises(ValueError, self.types, ':123')
def test_incorrect_ip(self):
self.assertRaises(ValueError, self.types, '127.surprise.0.1:2121')
def test_incorrect_port(self):
self.assertRaises(ValueError, self.types, '127.0.0.1:65536')
self.assertRaises(ValueError, self.types, '127.0.0.1:sample')

View File

@ -192,48 +192,6 @@ class TestPersister(base.BaseTestCase):
fake_kafka_config, 'zookeeper', fake_repository)
class TestPersisterConfig(base.BaseTestCase):
def setUp(self):
super(TestPersisterConfig, self).setUp()
from monasca_persister import persister
self.assertIsNotNone(persister)
def _test_zookeeper_options(self):
str_opts = ['uri']
int_opts = ['partition_interval_recheck_seconds']
self._assert_cfg_registered('zookeeper', str_opts, int_opts)
def _assert_cfg_registered(self, group_name, str_opts, int_opts):
options = {group_name: str_opts + int_opts}
for key, values in options.items():
for v in values:
self.assertIsNone(CONF[key][v])
def _test_kafka_options(self):
str_opts = ['uri', 'group_id', 'topic', 'consumer_id', 'client_id', 'zookeeper_path']
int_opts = ['database_batch_size', 'max_wait_time_seconds', 'fetch_size_bytes',
'buffer_size', 'max_buffer_size', 'num_processors']
self._assert_cfg_registered('kafka_metrics', str_opts, int_opts)
self._assert_cfg_registered('kafka_alarm_history', str_opts, int_opts)
def _test_repositories_options(self):
str_opts = ['metrics_driver', 'alarm_state_history_driver']
int_opts = []
self._assert_cfg_registered('repositories', str_opts, int_opts)
def test_correct_config_options_are_registered(self):
self._test_zookeeper_options()
self._test_kafka_options()
self._test_repositories_options()
def _get_process(name, is_alive=True):
return Mock(name=name, is_alive=Mock(return_value=is_alive))

View File

@ -20,12 +20,14 @@ setup-hooks =
console_scripts =
monasca-persister = monasca_persister.persister:main
oslo.config.opts =
monasca_persister = monasca_persister.conf:list_opts
[files]
packages =
monasca_persister
data_files =
/etc/monasca =
etc/monasca/persister.conf
etc/monasca/persister-logging.conf
[extras]

View File

@ -58,6 +58,12 @@ commands =
{[testenv:flake8]commands}
{[bandit]commands}
[testenv:genconfig]
description = Generates sample configuration file for monasca-persister
whitelist_externals = bash
commands =
oslo-config-generator --config-file=config-generator/persister.conf
[testenv:venv]
commands = {posargs}