def test_hook(self):
em = hook.HookManager(
'stevedore.test.extension',
't1',
invoke_on_load=True,
invoke_args=('a',),
invoke_kwds={'b': 'B'},
)
self.assertEqual(len(em.extensions), 1)
self.assertEqual(em.names(), ['t1'])
def test_hook():
em = hook.HookManager(
'stevedore.test.extension',
't1',
invoke_on_load=True,
invoke_args=('a', ),
invoke_kwds={'b': 'B'},
)
assert len(em.extensions) == 1
assert em.names() == ['t1']
def stevedore_hook(namespace, name):
print "--- hook.HookManager(%s,%s) ---" % (namespace,name)
mgr = hook.HookManager(
namespace = namespace,
name = name,
invoke_on_load = True,
)
def catch_all(ext):
return (ext.name, ext.obj.catch())
results = mgr.map(catch_all)
def test_get_by_name(self):
em = hook.HookManager(
'stevedore.test.extension',
't1',
invoke_on_load=True,
invoke_args=('a',),
invoke_kwds={'b': 'B'},
)
e_list = em['t1']
self.assertEqual(len(e_list), 1)
e = e_list[0]
self.assertEqual(e.name, 't1')
def test_get_by_name():
em = hook.HookManager(
'stevedore.test.extension',
't1',
invoke_on_load=True,
invoke_args=('a', ),
invoke_kwds={'b': 'B'},
)
e_list = em['t1']
assert len(e_list) == 1
e = e_list[0]
assert e.name == 't1'
def test_get_by_name_missing(self):
em = hook.HookManager(
'stevedore.test.extension',
't1',
invoke_on_load=True,
invoke_args=('a',),
invoke_kwds={'b': 'B'},
)
try:
em['t2']
except KeyError:
pass
else:
assert False, 'Failed to raise KeyError'
def __init__(self, conf):
self._conf = conf
module = Module.ALARM_GENERATOR
self._moduleid = ModuleNames[module]
node_type = Module2NodeType[module]
self._node_type_name = NodeTypeNames[node_type]
self._hostname = socket.gethostname()
self._instance_id = self._conf.worker_id()
sandesh_global.init_generator(self._moduleid, self._hostname,
self._node_type_name, self._instance_id,
self._conf.collectors(),
self._node_type_name,
self._conf.http_port(),
['opserver.sandesh', 'sandesh'])
sandesh_global.set_logging_params(
enable_local_log=self._conf.log_local(),
category=self._conf.log_category(),
level=self._conf.log_level(),
file=self._conf.log_file(),
enable_syslog=self._conf.use_syslog(),
syslog_facility=self._conf.syslog_facility())
self._logger = sandesh_global._logger
# Trace buffer list
self.trace_buf = [
{'name':'DiscoveryMsg', 'size':1000}
]
# Create trace buffers
for buf in self.trace_buf:
sandesh_global.trace_buffer_create(name=buf['name'], size=buf['size'])
tables = [ "ObjectCollectorInfo",
"ObjectDatabaseInfo",
"ObjectVRouter",
"ObjectBgpRouter",
"ObjectConfigNode" ]
self.mgrs = {}
self.tab_alarms = {}
for table in tables:
self.mgrs[table] = hook.HookManager(
namespace='contrail.analytics.alarms',
name=table,
invoke_on_load=True,
invoke_args=(),
on_load_failure_callback=Controller.fail_cb
)
for extn in self.mgrs[table][table]:
self._logger.info('Loaded extensions for %s: %s,%s' % \
(table, extn.name, extn.entry_point_target))
self.tab_alarms[table] = {}
ConnectionState.init(sandesh_global, self._hostname, self._moduleid,
self._instance_id,
staticmethod(ConnectionState.get_process_state_cb),
NodeStatusUVE, NodeStatus)
self._us = UVEServer(None, self._logger, self._conf.redis_password())
self._workers = {}
self.disc = None
self._libpart_name = self._hostname + ":" + self._instance_id
self._libpart = None
self._partset = set()
if self._conf.discovery()['server']:
import discoveryclient.client as client
data = {
'ip-address': self._hostname ,
'port': self._instance_id
}
self.disc = client.DiscoveryClient(
self._conf.discovery()['server'],
self._conf.discovery()['port'],
ModuleNames[Module.ALARM_GENERATOR])
self._logger.info("Disc Publish to %s : %s"
% (str(self._conf.discovery()), str(data)))
self.disc.publish(ALARM_GENERATOR_SERVICE_NAME, data)
else:
# If there is no discovery service, use fixed redis_uve list
redis_uve_list = []
try:
for redis_uve in self._conf.redis_uve_list():
redis_ip_port = redis_uve.split(':')
redis_ip_port = (redis_ip_port[0], int(redis_ip_port[1]))
redis_uve_list.append(redis_ip_port)
except Exception as e:
self._logger.error('Failed to parse redis_uve_list: %s' % e)
else:
self._us.update_redis_uve_list(redis_uve_list)
# If there is no discovery service, use fixed alarmgen list
self._libpart = self.start_libpart(self._conf.alarmgen_list())
PartitionOwnershipReq.handle_request = self.handle_PartitionOwnershipReq
PartitionStatusReq.handle_request = self.handle_PartitionStatusReq
UVETableAlarmReq.handle_request = self.handle_UVETableAlarmReq
def hook_manager(self, name):
LOG.debug('Looking for hooks with: %s %s', self.NAMESPACE, name)
return hook.HookManager(self.NAMESPACE, name)
decorator = ext.plugin(self.group)
f = decorator(f)
f._hook_point = self # add ourselves for inspection
return f
def __call__(self, f):
# Set up all our hook information based on the function or
# hook point
self.init_hook(f)
for h in self.hooks:
f = self.enable_hook(h, f)
return f
if __name__ == '__main__':
# Use this script to find existing hook points.
hook_names = sys.argv[1:]
print('Using namespace: %s' % hook_point.NAMESPACE)
print('pkg_resources has the following entry points:')
for ep in pkg_resources.iter_entry_points(hook_point.NAMESPACE):
print(ep)
print()
print('stevedore found the following hooks:')
for name in hook_names:
for hp in hook.HookManager(hook_point.NAMESPACE, name):
print(hp)
parser.add_argument(
'--width',
default=60,
type=int,
help='maximum output width for text',
)
parsed_args = parser.parse_args()
data = {
'a': 'A',
'b': 'B',
'long': 'word ' * 80,
}
mgr = hook.HookManager(
namespace='stevedoretest.formatter',
name=parsed_args.format,
invoke_on_load=True,
invoke_args=(parsed_args.width, ),
)
def format_data(ext, data):
return (ext.name, ext.obj.format(data))
results = mgr.map(format_data, data)
for name, result in results:
print('Formatter: %s' % name)
for chunk in result:
print(chunk)