def test_time_based_query():
events_1 = Event.query(start_after=300)
events_2 = Event.query(start_before=300)
events_3 = Event.query(start_after=200, start_before=400)
self.assertTrue(events_1.count() * 10 == cnt_all * 4)
self.assertTrue(events_2.count() * 10 == cnt_all * 6)
self.assertTrue(events_3.count() * 10 == cnt_all * 4)
def run_wf(wf_name=''):
"""
TODO:
1. make wf_name meaningful
2. refact it so as to reduce redundant code
3. how to response gracefully if error/exception occurs
4. the response should be contained the state of the workflow triggered
:http param async:
:return:
"""
is_async = request.args.get('async', False)
event, req = None, request.args
if request.method == 'POST':
event = Event.from_json(request.data)
event.save()
stat_driver.add_event(event)
async_results = reactor.dispatch_event(event=event,
wf_name=wf_name,
req=req)
else:
async_results = reactor.dispatch_req(wf_name, req, event=event)
if not is_async:
for ar in async_results:
ar.wait()
return json.dumps([ar.wf_id for ar in async_results])
def test_query(self):
all_event = Event.query()
cnt_all = all_event.count()
def test_time_based_query():
events_1 = Event.query(start_after=300)
events_2 = Event.query(start_before=300)
events_3 = Event.query(start_after=200, start_before=400)
self.assertTrue(events_1.count() * 10 == cnt_all * 4)
self.assertTrue(events_2.count() * 10 == cnt_all * 6)
self.assertTrue(events_3.count() * 10 == cnt_all * 4)
test_time_based_query()
query_by_name = Event.query(name=self.names[0])
query_by_entity = Event.query(entity=self.entities[0])
self.assertTrue(query_by_name.count() == query_by_entity.count())
def test_get_tags(self):
target_tags = set()
for ts in self.tags:
for k, v in ts.iteritems():
target_tags.add('%s=%s' % (k, v))
tags = Event.get_tags()
print tags
self.assertTrue(tags == target_tags)
def on_message(self, headers, message):
# TODO: should we validate the message format and field type here?
try:
event = Event.from_json(message)
self.stat_driver.add_event(event)
self.reactor.dispatch_event(event)
except:
self.logger.exception('failed to process message: ' + message)
else:
msg_id = headers['message-id']
self.conn.ack(msg_id, self.subscription_id)
def evolve(self, raw_event, states):
next_shot = 0
for state in states:
while True:
now = time.time()
if next_shot < now:
raw_event['state'] = state
next_shot = now + random.randint(5, 10)
break
else:
yield
raw_event['start'] = int(time.time() * 1000)
self.publisher.publish(Event(**raw_event))
def _generate_data(self):
self.names = ['name-' + str(n) for n in xrange(10)]
self.entities = ['host-' + str(n) for n in xrange(10)]
tags = [['key-' + str(k), 'value-' + str(v)] for k in xrange(5)
for v in xrange(3)]
self.tags = [dict(tags[0::3]), dict(tags[1::3]), dict(tags[2::3])]
starts = [100, 200, 300, 400, 500]
for state in EventState.alls:
for i in xrange(len(self.names)):
name, entity = self.names[i], self.entities[i]
for ts in self.tags:
for start in starts:
Event(name=name, entity=entity, tags=ts,
start=start).save()
def get_events():
args = request.args
name = args.get('name', None)
entity = args.get('entity', None)
tags = json.loads(args.get('tags', '{}'))
state = args.get('state', None)
start_before = args.get('startBefore', None)
start_after = args.get('startAfter', None)
limit = args.get('limit', 100)
events = Event.query(name=name,
entity=entity,
tags=tags,
state=state,
start_before=start_before and int(start_before),
start_after=start_after and int(start_after))
events = events.limit(limit).order_by('-start')
return json.dumps(events.as_pymongo())
def gen_event(self, state, timestamp):
return Event(name='test_ttr',
entity='localhost',
tags={'cluster': 'test'},
start=timestamp,
state=state)
def test_get_entities(self):
entities = Event.get_entities()
self.assertTrue(set(entities) == set(self.entities))
def test_get_names(self):
names = Event.get_names()
self.assertTrue(set(names) == set(self.names))
def _get_event(self, name, entity='ojr-test', state='critical', tags={}):
default = {'cluster': 'jy', 'role': 'DataNode', 'ip': '10.11.12.13'}
default.update(tags)
return Event(name=name, entity=entity, state=state, tags=default)