def get_app(self):
urls = [
("/run", saltnado.RunSaltAPIHandler),
]
application = self.build_tornado_app(urls)
application.event_listener = saltnado.EventListener({}, self.opts)
return application
async def test_simple(sock_dir):
"""
Test getting a few events
"""
with eventpublisher_process(sock_dir):
with salt.utils.event.MasterEvent(sock_dir) as me:
request = Request()
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": sock_dir,
"transport": "zeromq"
},
)
event_future = event_listener.get_event(
request, "evt1") # get an event future
me.fire_event({"data": "foo2"},
"evt2") # fire an event we don't want
me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want
await event_future # wait for the future
# check that we got the event we wanted
assert event_future.done()
assert event_future.result()["tag"] == "evt1"
assert event_future.result()["data"]["data"] == "foo1"
def test_set_event_handler(self):
"""
Test subscribing events using set_event_handler
"""
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": self.sock_dir,
"transport": "zeromq"
},
)
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self,
tag="evt",
callback=self.stop,
timeout=1,
) # get an event future
me.fire_event({"data": "foo"}, "evt") # fire an event we do want
self.wait()
# check that we subscribed the event we wanted
self.assertEqual(len(event_listener.timeout_map), 0)
def test_simple(self):
"""
Test getting a few events
"""
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": self.sock_dir,
"transport": "zeromq"
},
)
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self, "evt1", callback=self.stop) # get an event future
me.fire_event({"data": "foo2"},
"evt2") # fire an event we don't want
me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want
self.wait() # wait for the future
# check that we got the event we wanted
self.assertTrue(event_future.done())
self.assertEqual(event_future.result()["tag"], "evt1")
self.assertEqual(event_future.result()["data"]["data"], "foo1")
async def test_set_event_handler(sock_dir):
"""
Test subscribing events using set_event_handler
"""
with eventpublisher_process(sock_dir):
with salt.utils.event.MasterEvent(sock_dir) as me:
request = Request()
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": sock_dir,
"transport": "zeromq"
},
)
event_future = event_listener.get_event(
request,
tag="evt",
timeout=1,
) # get an event future
me.fire_event({"data": "foo"}, "evt") # fire an event we do want
await event_future # wait for the future
# check that we subscribed the event we wanted
assert len(event_listener.timeout_map) == 0
def get_app(self):
urls = [(r"/jobs/(.*)", saltnado.JobsSaltAPIHandler),
(r"/jobs", saltnado.JobsSaltAPIHandler),
]
application = self.build_tornado_app(urls)
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def test_simple(self):
"""
Test getting a few events
'''
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self, "evt1", callback=self.stop
) # get an event future
me.fire_event({"data": "foo2"}, "evt2") # fire an event we don't want
me.fire_event({"data": "foo1"}, "evt1") # fire an event we do want
self.wait() # wait for the future
# check that we got the event we wanted
self.assertTrue(event_future.done())
self.assertEqual(event_future.result()["tag"], "evt1")
self.assertEqual(event_future.result()["data"]["data"], "foo1")
@skipIf(True, "SLOWTEST skip")
def test_set_event_handler(self):
"""
Test subscribing events using set_event_handler
'''
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self, tag="evt", callback=self.stop, timeout=1,
) # get an event future
me.fire_event({"data": "foo"}, "evt") # fire an event we do want
self.wait()
# check that we subscribed the event we wanted
self.assertEqual(len(event_listener.timeout_map), 0)
@skipIf(True, "SLOWTEST skip")
def test_timeout(self):
"""
Make sure timeouts work correctly
'''
with eventpublisher_process(self.sock_dir):
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self, tag="evt1", callback=self.stop, timeout=1,
) # get an event future
self.wait()
self.assertTrue(event_future.done())
with self.assertRaises(saltnado.TimeoutException):
event_future.result()
def get_app(self):
urls = [('/', saltnado.SaltAPIHandler)]
application = self.build_tornado_app(urls)
application.event_listener = saltnado.EventListener({}, self.opts)
self.application = application
return application
def get_app(self):
application = tornado.web.Application([('/', saltnado.SaltAPIHandler)], debug=True)
application.auth = self.auth
application.opts = self.opts
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def get_app(self):
application = tornado.web.Application([(r"/jobs/(.*)", saltnado.JobsSaltAPIHandler),
(r"/jobs", saltnado.JobsSaltAPIHandler),
], debug=True)
application.auth = self.auth
application.opts = self.opts
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def get_app(self):
urls = [(r"/events", saltnado.EventsSaltAPIHandler),
]
application = self.build_tornado_app(urls)
application.event_listener = saltnado.EventListener({}, self.opts)
# store a reference, for magic later!
self.application = application
self.events_to_fire = 0
return application
def get_app(self):
urls = [(r"/hook(/.*)?", saltnado.WebhookSaltAPIHandler),
]
application = self.build_tornado_app(urls)
self.application = application
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def get_app(self):
application = tornado.web.Application([(r"/hook(/.*)?", saltnado.WebhookSaltAPIHandler),
], debug=True)
application.auth = self.auth
application.opts = self.opts
self.application = application
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def get_app(self):
application = tornado.web.Application([(r"/events", saltnado.EventsSaltAPIHandler),
], debug=True)
application.auth = self.auth
application.opts = self.opts
application.event_listener = saltnado.EventListener({}, self.opts)
# store a reference, for magic later!
self.application = application
self.events_to_fire = 0
return application
def build_tornado_app(
urls, load_auth, client_config, minion_config, setup_event_listener=False
):
application = salt.ext.tornado.web.Application(urls, debug=True)
application.auth = load_auth
application.opts = client_config
application.mod_opts = minion_config
if setup_event_listener:
application.event_listener = saltnado.EventListener(
minion_config, client_config
)
return application
def test_timeout(self):
"""
Make sure timeouts work correctly
"""
with eventpublisher_process(self.sock_dir):
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{"sock_dir": self.sock_dir, "transport": "zeromq"},
)
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(
self, tag="evt1", callback=self.stop, timeout=1,
) # get an event future
self.wait()
self.assertTrue(event_future.done())
with self.assertRaises(saltnado.TimeoutException):
event_future.result()
def test_timeout(self):
'''
Make sure timeouts work correctly
'''
with eventpublisher_process():
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': SOCK_DIR,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(self,
tag='evt1',
callback=self.stop,
timeout=1,
) # get an event future
self.wait()
self.assertTrue(event_future.done())
with self.assertRaises(saltnado.TimeoutException):
event_future.result()
def test_simple(self):
'''
Test getting a few events
'''
with eventpublisher_process():
me = event.MasterEvent(SOCK_DIR)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': SOCK_DIR,
'transport': 'zeromq'})
event_future = event_listener.get_event(1, 'evt1', self.stop) # get an event future
me.fire_event({'data': 'foo2'}, 'evt2') # fire an event we don't want
me.fire_event({'data': 'foo1'}, 'evt1') # fire an event we do want
self.wait() # wait for the future
# check that we got the event we wanted
self.assertTrue(event_future.done())
self.assertEqual(event_future.result()['tag'], 'evt1')
self.assertEqual(event_future.result()['data']['data'], 'foo1')
def test_simple(self):
'''
Test getting a few events
'''
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(self, 'evt1', callback=self.stop) # get an event future
me.fire_event({'data': 'foo2'}, 'evt2') # fire an event we don't want
me.fire_event({'data': 'foo1'}, 'evt1') # fire an event we do want
self.wait() # wait for the future
# check that we got the event we wanted
self.assertTrue(event_future.done())
self.assertEqual(event_future.result()['tag'], 'evt1')
self.assertEqual(event_future.result()['data']['data'], 'foo1')
def test_set_event_handler(self):
'''
Test subscribing events using set_event_handler
'''
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self._finished = False # fit to event_listener's behavior
event_future = event_listener.get_event(self,
tag='evt',
callback=self.stop,
timeout=1,
) # get an event future
me.fire_event({'data': 'foo'}, 'evt') # fire an event we do want
self.wait()
# check that we subscribed the event we wanted
self.assertEqual(len(event_listener.timeout_map), 0)
async def test_timeout(sock_dir):
"""
Make sure timeouts work correctly
"""
with eventpublisher_process(sock_dir):
request = Request()
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": sock_dir,
"transport": "zeromq"
},
)
event_future = event_listener.get_event(
request,
tag="evt1",
timeout=1,
) # get an event future
with pytest.raises(saltnado.TimeoutException):
await event_future # wait for the future
assert event_future.done()
def test_clean_by_request(self):
'''
Make sure the method clean_by_request clean up every related data in EventListener
request_future_1 : will be timeout-ed by clean_by_request(self)
request_future_2 : will be finished by me.fire_event ...
dummy_request_future_1 : will be finished by me.fire_event ...
dummy_request_future_2 : will be timeout-ed by clean-by_request(dummy_request)
'''
class DummyRequest(object):
'''
Dummy request object to simulate the request object
'''
@property
def _finished(self):
'''
Simulate _finished of the request object
'''
return False
# Inner functions never permit modifying primitive values directly
cnt = [0]
def stop():
'''
To realize the scenario of this test, define a custom stop method to call
self.stop after finished two events.
'''
cnt[0] += 1
if cnt[0] == 2:
self.stop()
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener({}, # we don't use mod_opts, don't save?
{'sock_dir': self.sock_dir,
'transport': 'zeromq'})
self.assertEqual(0, len(event_listener.tag_map))
self.assertEqual(0, len(event_listener.request_map))
self._finished = False # fit to event_listener's behavior
dummy_request = DummyRequest()
request_future_1 = event_listener.get_event(self, tag='evt1')
request_future_2 = event_listener.get_event(self, tag='evt2', callback=lambda f: stop())
dummy_request_future_1 = event_listener.get_event(dummy_request, tag='evt3', callback=lambda f: stop())
dummy_request_future_2 = event_listener.get_event(dummy_request, timeout=10, tag='evt4')
self.assertEqual(4, len(event_listener.tag_map))
self.assertEqual(2, len(event_listener.request_map))
me.fire_event({'data': 'foo2'}, 'evt2')
me.fire_event({'data': 'foo3'}, 'evt3')
self.wait()
event_listener.clean_by_request(self)
me.fire_event({'data': 'foo1'}, 'evt1')
self.assertTrue(request_future_1.done())
with self.assertRaises(saltnado.TimeoutException):
request_future_1.result()
self.assertTrue(request_future_2.done())
self.assertEqual(request_future_2.result()['tag'], 'evt2')
self.assertEqual(request_future_2.result()['data']['data'], 'foo2')
self.assertTrue(dummy_request_future_1.done())
self.assertEqual(dummy_request_future_1.result()['tag'], 'evt3')
self.assertEqual(dummy_request_future_1.result()['data']['data'], 'foo3')
self.assertFalse(dummy_request_future_2.done())
self.assertEqual(2, len(event_listener.tag_map))
self.assertEqual(1, len(event_listener.request_map))
event_listener.clean_by_request(dummy_request)
with self.assertRaises(saltnado.TimeoutException):
dummy_request_future_2.result()
self.assertEqual(0, len(event_listener.tag_map))
self.assertEqual(0, len(event_listener.request_map))
async def test_clean_by_request(sock_dir, io_loop):
"""
Make sure the method clean_by_request clean up every related data in EventListener
request_future_1 : will be timeout-ed by clean_by_request(request1)
request_future_2 : will be finished by me.fire_event and awaiting for it ...
request_future_3 : will be finished by me.fire_event and awaiting for it ...
request_future_4 : will be timeout-ed by clean-by_request(request2)
"""
with eventpublisher_process(sock_dir):
with salt.utils.event.MasterEvent(sock_dir) as me:
request1 = Request()
request2 = Request()
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": sock_dir,
"transport": "zeromq"
},
)
assert 0 == len(event_listener.tag_map)
assert 0 == len(event_listener.request_map)
request_future_1 = event_listener.get_event(request1, tag="evt1")
request_future_2 = event_listener.get_event(request1, tag="evt2")
dummy_request_future_1 = event_listener.get_event(request2,
tag="evt3")
dummy_request_future_2 = event_listener.get_event(request2,
timeout=10,
tag="evt4")
assert 4 == len(event_listener.tag_map)
assert 2 == len(event_listener.request_map)
me.fire_event({"data": "foo2"}, "evt2")
me.fire_event({"data": "foo3"}, "evt3")
await request_future_2
await dummy_request_future_1
event_listener.clean_by_request(request1)
me.fire_event({"data": "foo1"}, "evt1")
assert request_future_1.done()
with pytest.raises(saltnado.TimeoutException):
request_future_1.result()
assert request_future_2.done()
assert request_future_2.result()["tag"] == "evt2"
assert request_future_2.result()["data"]["data"] == "foo2"
assert dummy_request_future_1.done()
assert dummy_request_future_1.result()["tag"] == "evt3"
assert dummy_request_future_1.result()["data"]["data"] == "foo3"
assert not dummy_request_future_2.done()
assert 2 == len(event_listener.tag_map)
assert 1 == len(event_listener.request_map)
event_listener.clean_by_request(request2)
with pytest.raises(saltnado.TimeoutException):
dummy_request_future_2.result()
assert 0 == len(event_listener.tag_map)
assert 0 == len(event_listener.request_map)
def test_clean_by_request(self):
"""
Make sure the method clean_by_request clean up every related data in EventListener
request_future_1 : will be timeout-ed by clean_by_request(self)
request_future_2 : will be finished by me.fire_event ...
dummy_request_future_1 : will be finished by me.fire_event ...
dummy_request_future_2 : will be timeout-ed by clean-by_request(dummy_request)
"""
class DummyRequest(object):
"""
Dummy request object to simulate the request object
"""
@property
def _finished(self):
"""
Simulate _finished of the request object
"""
return False
# Inner functions never permit modifying primitive values directly
cnt = [0]
def stop():
"""
To realize the scenario of this test, define a custom stop method to call
self.stop after finished two events.
"""
cnt[0] += 1
if cnt[0] == 2:
self.stop()
with eventpublisher_process(self.sock_dir):
me = salt.utils.event.MasterEvent(self.sock_dir)
event_listener = saltnado.EventListener(
{}, # we don't use mod_opts, don't save?
{
"sock_dir": self.sock_dir,
"transport": "zeromq"
},
)
self.assertEqual(0, len(event_listener.tag_map))
self.assertEqual(0, len(event_listener.request_map))
self._finished = False # fit to event_listener's behavior
dummy_request = DummyRequest()
request_future_1 = event_listener.get_event(self, tag="evt1")
request_future_2 = event_listener.get_event(
self, tag="evt2", callback=lambda f: stop())
dummy_request_future_1 = event_listener.get_event(
dummy_request, tag="evt3", callback=lambda f: stop())
dummy_request_future_2 = event_listener.get_event(dummy_request,
timeout=10,
tag="evt4")
self.assertEqual(4, len(event_listener.tag_map))
self.assertEqual(2, len(event_listener.request_map))
me.fire_event({"data": "foo2"}, "evt2")
me.fire_event({"data": "foo3"}, "evt3")
self.wait()
event_listener.clean_by_request(self)
me.fire_event({"data": "foo1"}, "evt1")
self.assertTrue(request_future_1.done())
with self.assertRaises(saltnado.TimeoutException):
request_future_1.result()
self.assertTrue(request_future_2.done())
self.assertEqual(request_future_2.result()["tag"], "evt2")
self.assertEqual(request_future_2.result()["data"]["data"], "foo2")
self.assertTrue(dummy_request_future_1.done())
self.assertEqual(dummy_request_future_1.result()["tag"], "evt3")
self.assertEqual(dummy_request_future_1.result()["data"]["data"],
"foo3")
self.assertFalse(dummy_request_future_2.done())
self.assertEqual(2, len(event_listener.tag_map))
self.assertEqual(1, len(event_listener.request_map))
event_listener.clean_by_request(dummy_request)
with self.assertRaises(saltnado.TimeoutException):
dummy_request_future_2.result()
self.assertEqual(0, len(event_listener.tag_map))
self.assertEqual(0, len(event_listener.request_map))
