def main(publish=False, no_app=False):
io_loop = tornado.ioloop.IOLoop.current()
application = tornado.web.Application([
(r'/', HeloHandler)
])
server = tornado.httpserver.HTTPServer(application)
server.listen(8080, '127.0.0.1')
if no_app:
tornado_app = None
else:
tornado_app = application
if publish:
monitor = initialize_mutornadomon(tornado_app=tornado_app,
io_loop=io_loop,
publisher=publisher,
publish_interval=5 * 1000)
else:
monitor = initialize_mutornadomon(tornado_app=tornado_app)
def stop(*args):
print('Good bye')
monitor.stop()
io_loop.stop()
for sig in signal.SIGINT, signal.SIGQUIT, signal.SIGTERM:
signal.signal(sig, stop)
tornado.ioloop.IOLoop.current().start()
def main(publish=False, no_app=False):
io_loop = tornado.ioloop.IOLoop.current()
application = tornado.web.Application([(r'/', HeloHandler)])
server = tornado.httpserver.HTTPServer(application)
server.listen(8080, '127.0.0.1')
if no_app:
tornado_app = None
else:
tornado_app = application
if publish:
monitor = initialize_mutornadomon(tornado_app=tornado_app,
io_loop=io_loop,
publisher=publisher,
publish_interval=5 * 1000)
else:
monitor = initialize_mutornadomon(tornado_app=tornado_app)
def stop(*args):
print('Good bye')
monitor.stop()
io_loop.stop()
for sig in signal.SIGINT, signal.SIGQUIT, signal.SIGTERM:
signal.signal(sig, stop)
tornado.ioloop.IOLoop.current().start()
def test_initialize_mutornadmon_passes_publisher(
self, utilization_collector_mock, web_collector_mock,
mutornadomon_mock):
"""Test initialize_mutornadomon() sets up publishing interface"""
def publisher(monitor):
pass
app = sentinel.application
result = initialize_mutornadomon(app,
publisher=publisher,
host_limit='test')
monitor_inst = mutornadomon_mock.return_value
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
web_collector_mock.assert_called_once_with(monitor_inst, app)
utilization_collector_mock.assert_called_once_with(monitor_inst)
assert mutornadomon_mock.call_count == 1
arg_list = mutornadomon_mock.call_args_list
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], PublishExternalInterface))
self.assertEqual(kwargs, {})
def setUp(self):
super(TestProfiler, self).setUp()
self.publisher = mock.Mock(return_value=None)
self.io_loop = IOLoop.current()
self.monitor = initialize_mutornadomon(io_loop=self.io_loop,
publisher=self.publisher,
tracer_port=5989)
def test_initialize_mutornadmon_passes_publisher(
self,
utilization_collector_mock,
web_collector_mock,
mutornadomon_mock
):
"""Test initialize_mutornadomon() sets up publishing interface"""
def publisher(monitor):
pass
app = sentinel.application
result = initialize_mutornadomon(app,
publisher=publisher,
host_limit='test')
monitor_inst = mutornadomon_mock.return_value
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
web_collector_mock.assert_called_once_with(monitor_inst, app)
utilization_collector_mock.assert_called_once_with(monitor_inst)
assert mutornadomon_mock.call_count == 1
arg_list = mutornadomon_mock.call_args_list
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], PublishExternalInterface))
self.assertEqual(kwargs, {})
def test_publisher_initializer(self, periodic_callback_mock):
"""Test instrument_ioloop() setups monitoring and creates a PeriodicCallback"""
def publisher():
pass
result = initialize_mutornadomon(
io_loop=tornado.ioloop.IOLoop.current(), publisher=publisher)
assert periodic_callback_mock.called
self.assertTrue(isinstance(result, mutornadomon.MuTornadoMon))
def test_publisher_initializer(self, periodic_callback_mock):
"""Test instrument_ioloop() setups monitoring and creates a PeriodicCallback"""
def publisher():
pass
result = initialize_mutornadomon(io_loop=tornado.ioloop.IOLoop.current(), publisher=publisher)
assert periodic_callback_mock.called
self.assertTrue(isinstance(result, mutornadomon.MuTornadoMon))
def test_publisher_called(self, mock_num_threads):
publisher = mock.Mock(return_value=None)
monitor = initialize_mutornadomon(io_loop=IOLoop.current(),
publisher=publisher)
monitor.count('my_counter', 2)
monitor.external_interface._publish(monitor)
self.assertTrue(publisher.called_once())
metrics = publisher.call_args_list[0][0][0]
self.assertEqual(metrics['counters'], {'my_counter': 2})
self.assertEqual(metrics['process']['cpu']['num_threads'], 5)
assert metrics['process']['cpu']['system_time'] < 1.0
def test_publisher_called(self, mock_num_threads):
publisher = mock.Mock(return_value=None)
monitor = initialize_mutornadomon(io_loop=IOLoop.current(), publisher=publisher)
monitor.count('my_counter', 2)
monitor.external_interface._publish(monitor)
self.assertTrue(publisher.called_once())
metrics = publisher.call_args_list[0][0][0]
self.assertEqual(
metrics['counters'],
{'my_counter': 2}
)
self.assertEqual(metrics['process']['cpu']['num_threads'], 5)
assert metrics['process']['cpu']['system_time'] < 1.0
def test_initialize_mutornadmon(self, mutornadomon_mock):
"""Test initialize_mutornadomon() setups monitoring and shutdown"""
result = initialize_mutornadomon(sentinel.application,
host_limit='test')
monitor_inst = mutornadomon_mock.MuTornadoMon.return_value
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
# MuTornadoMon was created with monitor config values
mutornadomon_mock.MuTornadoMon.assert_called_once_with(
host_limit='test')
# Monitor instance was registered with tornado application
monitor_inst.register_application.assert_called_once_with(
sentinel.application)
def main():
application = tornado.web.Application([
(r'/', HeloHandler)
])
server = tornado.httpserver.HTTPServer(application)
server.listen(8080, '127.0.0.1')
monitor = initialize_mutornadomon(application)
def stop(*args):
print 'Good bye'
monitor.stop()
tornado.ioloop.IOLoop.current().stop()
for sig in signal.SIGINT, signal.SIGQUIT, signal.SIGTERM:
signal.signal(sig, stop)
tornado.ioloop.IOLoop.current().start()
def test_initialize_mutornadmon(self, utilization_collector_mock, web_collector_mock, mutornadomon_mock):
"""Test initialize_mutornadomon() sets up HTTP endpoints interface"""
app = sentinel.application,
result = initialize_mutornadomon(app, host_limit='test')
monitor_inst = mutornadomon_mock.return_value
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
assert mutornadomon_mock.call_count == 1
web_collector_mock.assert_called_once_with(monitor_inst, app)
utilization_collector_mock.assert_called_once_with(monitor_inst)
# MuTornadoMon was created with monitor config values
arg_list = mutornadomon_mock.call_args_list
self.assertEquals(len(arg_list), 1)
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], HTTPEndpointExternalInterface))
self.assertEqual(kwargs, {})
def test_initialize_mutornadmon(self, utilization_collector_mock,
web_collector_mock, mutornadomon_mock):
"""Test initialize_mutornadomon() sets up HTTP endpoints interface"""
app = sentinel.application,
result = initialize_mutornadomon(app, host_limit='test')
monitor_inst = mutornadomon_mock.return_value
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
assert mutornadomon_mock.call_count == 1
web_collector_mock.assert_called_once_with(monitor_inst, app)
utilization_collector_mock.assert_called_once_with(monitor_inst)
# MuTornadoMon was created with monitor config values
arg_list = mutornadomon_mock.call_args_list
self.assertEquals(len(arg_list), 1)
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], HTTPEndpointExternalInterface))
self.assertEqual(kwargs, {})
def test_initialize_mutornadmon_works_with_publisher_and_no_app(
self, mutornadomon_mock):
"""Test initialize_mutornadomon() works with publisher, but no web app passed"""
def publisher(monitor):
pass
monitor_inst = mutornadomon_mock.return_value
result = initialize_mutornadomon(publisher=publisher)
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
assert mutornadomon_mock.call_count == 1
# MuTornadoMon was created with monitor config values
arg_list = mutornadomon_mock.call_args_list
self.assertEquals(len(arg_list), 1)
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], PublishExternalInterface))
# No collectors are passed
self.assertEqual(kwargs, {})
def test_initialize_mutornadmon_works_with_publisher_and_no_app(self, mutornadomon_mock):
"""Test initialize_mutornadomon() works with publisher, but no web app passed"""
def publisher(monitor):
pass
monitor_inst = mutornadomon_mock.return_value
result = initialize_mutornadomon(publisher=publisher)
# initialize_mutornadomon() should return the monitor instance
self.assertEqual(result, monitor_inst)
assert mutornadomon_mock.call_count == 1
# MuTornadoMon was created with monitor config values
arg_list = mutornadomon_mock.call_args_list
self.assertEquals(len(arg_list), 1)
args, kwargs = arg_list[0]
self.assertEqual(len(args), 1)
self.assertTrue(isinstance(args[0], PublishExternalInterface))
# No collectors are passed
self.assertEqual(kwargs, {})
if __name__ == '__main__':
rootLogger = logging.getLogger(__name__)
tcp_conf = dict(globalsObj.configuration.items('TCP'))
# write pid file
commonlib.writePid(globalsObj.configuration.get('pid', 'file'))
# create app
globalsObj.ws_configuration.read_dict(globalsObj.deniedPath)
webapp = WebApp(globalsObj.configuration, globalsObj.ws_configuration)
# initialize monitor
if globalsObj.configuration.getboolean('Monitor', 'enable'):
monitor = initialize_mutornadomon(webapp,
request_filter=commonlib.match_host)
for sig in (signal.SIGQUIT, signal.SIGINT, signal.SIGTERM):
signal.signal(sig, shut_down)
# set backend to serilize objects
jsonpickle.set_preferred_backend('simplejson')
jsonpickle.set_encoder_options('simplejson', ensure_ascii=True, indent=4)
try:
sockets = tornado.netutil.bind_sockets(
tcp_conf['port'],
tcp_conf['address'],
family=socket.AF_INET,
backlog=int(tcp_conf['backlog']),
reuse_port=bool(tcp_conf['reuseport']))
def main():
parser = optparse.OptionParser()
parser.add_option(
'-c',
'--config-file',
default=None,
help='Path to a YAML config file'
)
parser.add_option(
'-p',
'--port',
default=[],
type=int,
action='append',
help='Port to listen on. May be repeated. If not passed, defaults to :3333.'
)
parser.add_option(
'-B',
'--bind-address',
default='0.0.0.0',
help='Address to listen on. Defaults to %default'
)
parser.add_option(
'--spool-root',
default='/var/spool/hacheck',
help='Root for spool for service states (default %default)'
)
parser.add_option(
'-v',
'--verbose',
default=False,
action='store_true'
)
opts, args = parser.parse_args()
if opts.config_file is not None:
config.load_from(opts.config_file)
if not opts.port:
opts.port = [3333]
if config.config['rlimit_nofile'] is not None:
setrlimit_nofile(config.config['rlimit_nofile'])
# set up logging
log_path = config.config['log_path']
level = logging.DEBUG if opts.verbose else logging.WARNING
if log_path == 'stdout':
handler = logging.StreamHandler(sys.stdout)
elif log_path == 'stderr':
handler = logging.StreamHandler(sys.stderr)
else:
handler = logging.handlers.WatchedFileHandler(log_path)
fmt = logging.Formatter(logging.BASIC_FORMAT, None)
handler.setFormatter(fmt)
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(level)
# application stuff
cache.configure(cache_time=config.config['cache_time'])
spool.configure(spool_root=opts.spool_root)
application = get_app()
ioloop = tornado.ioloop.IOLoop.instance()
server = tornado.httpserver.HTTPServer(application, io_loop=ioloop)
if initialize_mutornadomon is not None:
mutornadomon_collector = initialize_mutornadomon(application, io_loop=ioloop)
else:
mutornadomon_collector = None
def stop(*args):
if mutornadomon_collector is not None:
mutornadomon_collector.stop()
ioloop.stop()
for port in opts.port:
server.listen(port, opts.bind_address)
for sig in (signal.SIGTERM, signal.SIGQUIT, signal.SIGINT):
signal.signal(sig, stop)
ioloop.start()
return 0
def setUp(self):
super(TestBasic, self).setUp()
self.monitor = initialize_mutornadomon(self.app)
def setUp(self):
super(TestBasic, self).setUp()
self.monitor = initialize_mutornadomon(self.app)
def main():
parser = optparse.OptionParser()
parser.add_option('-c',
'--config-file',
default=None,
help='Path to a YAML config file')
parser.add_option(
'-p',
'--port',
default=[],
type=int,
action='append',
help=
'Port to listen on. May be repeated. If not passed, defaults to :3333.'
)
parser.add_option(
'-n',
'--num-procs',
default=1,
type=int,
help='Number of identical copies to run',
)
parser.add_option('-B',
'--bind-address',
default='0.0.0.0',
help='Address to listen on. Defaults to %default')
parser.add_option(
'--spool-root',
default='/var/spool/hacheck',
help='Root for spool for service states (default %default)')
parser.add_option('-v', '--verbose', default=False, action='store_true')
opts, args = parser.parse_args()
if opts.config_file is not None:
config.load_from(opts.config_file)
if not opts.port:
opts.port = [3333]
if config.config['rlimit_nofile'] is not None:
setrlimit_nofile(config.config['rlimit_nofile'])
# set up logging
log_path = config.config['log_path']
level = logging.DEBUG if opts.verbose else logging.WARNING
if log_path == 'stdout':
handler = logging.StreamHandler(sys.stdout)
elif log_path == 'stderr':
handler = logging.StreamHandler(sys.stderr)
else:
handler = logging.handlers.WatchedFileHandler(log_path)
fmt = logging.Formatter(logging.BASIC_FORMAT, None)
handler.setFormatter(fmt)
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(level)
# application stuff
cache.configure(cache_time=config.config['cache_time'])
spool.configure(spool_root=opts.spool_root)
application = get_app()
server = tornado.httpserver.HTTPServer(application)
if initialize_mutornadomon is not None:
mutornadomon_collector = initialize_mutornadomon(application)
else:
mutornadomon_collector = None
def stop(*args):
if mutornadomon_collector is not None:
mutornadomon_collector.stop()
IOLoop.current().stop()
for port in opts.port:
server.bind(port, opts.bind_address, reuse_port=True)
for sig in (signal.SIGTERM, signal.SIGQUIT, signal.SIGINT):
signal.signal(sig, stop)
server.start(opts.num_procs)
IOLoop.current().remove_timeout = types.MethodType(remove_timeout,
IOLoop.current())
IOLoop.current().start()
return 0
def setUp(self):
super(TestProfiler, self).setUp()
self.publisher = mock.Mock(return_value=None)
self.io_loop = IOLoop.current()
self.monitor = initialize_mutornadomon(
io_loop=self.io_loop, publisher=self.publisher, tracer_port=5989)
