def connect(emitter, receiver, mapping=None, events=None):
if mapping is None:
mapping = guess_mapping(emitter, receiver)
# XXX: we didn't agree on that "reverse" there
location_and_transports(emitter, receiver, mapping)
if isinstance(mapping, set):
mapping = {src: src for src in mapping}
for src, dst in mapping.items():
if not isinstance(dst, list):
dst = [dst]
for d in dst:
connect_single(emitter, src, receiver, d)
events_to_add = [
Dependency(emitter.name, 'run', 'success', receiver.name, 'run'),
Dependency(emitter.name, 'update', 'success', receiver.name, 'update')
]
if isinstance(events, dict):
for k, v in events.items():
if v is not False:
events_to_add = filter(lambda x: x.parent_action == k, events_to_add)
add_events(emitter.name, events_to_add)
elif events is not False:
add_events(emitter.name, events_to_add)
def test_remove_events(events_example):
r = orm.DBResource(id='e1', name='e1', base_path='x')
r.save()
to_be_removed = events_example[2]
evapi.add_events('e1', events_example)
evapi.remove_event(to_be_removed)
assert to_be_removed not in evapi.all_events('e1')
def connect_with_events(self, receiver, mapping=None, events=None,
use_defaults=False):
signals.connect(self, receiver, mapping=mapping)
if use_defaults:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def test_riak():
events = {
'riak_service1': [
evapi.React('riak_service1', 'run', 'success', 'riak_service2',
'run'),
evapi.React('riak_service1', 'run', 'success',
'riak_service3', 'run')
],
'riak_service3': [
evapi.React('riak_service3', 'join', 'success', 'riak_service1',
'commit'),
evapi.React('riak_service3', 'run', 'success', 'riak_service3',
'join')
],
'riak_service2': [
evapi.React('riak_service2', 'run', 'success', 'riak_service2',
'join'),
evapi.React('riak_service2', 'join', 'success', 'riak_service1',
'commit')
],
}
for name in events:
res = Resource.from_dict({'key': name, 'name': name})
res.save()
res.inputs.add_new('location_id', '1')
evapi.add_events(name, events[name])
changes_graph = nx.MultiDiGraph()
changes_graph.add_node('riak_service1.run')
evapi.build_edges(changes_graph, events)
assert set(changes_graph.predecessors('riak_service1.commit')) == {
'riak_service2.join', 'riak_service3.join'
}
def test_remove_events(events_example):
r = Resource.from_dict(dict(key='e1', name='e1', base_path='x'))
r.save()
to_be_removed = events_example[2]
evapi.add_events('e1', events_example)
evapi.remove_event(to_be_removed)
assert to_be_removed not in evapi.all_events('e1')
def test_set_events(events_example):
r = orm.DBResource(id='e1', name='e1', base_path='x')
r.save()
partial = events_example[:2]
evapi.add_events('e1', events_example[:2])
evapi.set_events('e1', events_example[2:])
assert evapi.all_events('e1') == events_example[2:]
def connect_with_events(self, receiver, mapping=None, events=None,
use_defaults=False):
mapping = get_mapping(self, receiver, mapping)
self._connect_inputs(receiver, mapping)
# signals.connect(self, receiver, mapping=mapping)
# TODO: implement events
if use_defaults:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def connect_with_events(self,
receiver,
mapping=None,
events=None,
use_defaults=False):
signals.connect(self, receiver, mapping=mapping)
if use_defaults:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def connect_with_events(self,
receiver,
mapping=None,
events=None,
use_defaults=False):
mapping = get_mapping(self, receiver, mapping)
self._connect_inputs(receiver, mapping)
# signals.connect(self, receiver, mapping=mapping)
# TODO: implement events
if use_defaults:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def nova_deps():
for name in ['nova', 'nova_api', 'nova_sch']:
r = Resource.from_dict(dict(key=name, name=name))
r.inputs.add_new('location_id', '1')
r.save()
nova = [
evapi.Dep('nova', 'run', 'success', 'nova_sch', 'run'),
evapi.React('nova', 'run', 'success', 'nova_api', 'update')]
nova_api = [
evapi.React('nova_api', 'update', 'success', 'nova', 'reboot')]
evapi.add_events('nova', nova)
evapi.add_events('nova_api', nova_api)
return {'nova': nova}
def test_mandatory_revisit():
events = {
'e1': [evapi.Dep('e1', 'run', 'success', 'e2', 'run'),
evapi.React('e1', 'run', 'success', 'e2', 'start')],
'e2': [evapi.React('e2', 'start', 'success', 'e2', 'run')]}
for name in events:
r = Resource.from_dict(dict(key=name, name=name))
r.inputs.add_new('location_id', '1')
r.save()
evapi.add_events(name, events[name])
changes_graph = nx.DiGraph()
changes_graph.add_node('e1.run')
evapi.build_edges(changes_graph, events)
assert set(changes_graph.predecessors('e2.run')) == {'e1.run', 'e2.start'}
def connect_with_events(self, receiver, mapping=None, events=None,
use_defaults=False):
mapping = get_mapping(self, receiver, mapping)
self._connect_inputs(receiver, mapping)
LogItem.new({'resource': receiver.name,
'action': 'run',
'tags': receiver.tags}).save_lazy()
# signals.connect(self, receiver, mapping=mapping)
# TODO: implement events
if use_defaults:
if self != receiver:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def fuel_data(nobj):
uid = str(nobj.data['id'])
env_id = nobj.data['cluster']
node = resource.load('node{}'.format(uid))
res = resource.Resource('fuel_data{}'.format(uid), 'f2s/fuel_data',
{'uid': uid,
'env': env_id}, tags=['node%s' % nobj.data['id']])
events = [
evapi.React(res.name, 'run', 'success',
'pre_deployment_start', 'run'),
evapi.React(res.name, 'update', 'success',
'pre_deployment_start', 'run')]
evapi.add_events(res.name, events)
node = resource.load('node{}'.format(uid))
node.connect(res, {})
def fuel_data(nobj):
uid = str(nobj.data['id'])
env_id = nobj.data['cluster']
node = resource.load('node{}'.format(uid))
res = resource.Resource('fuel_data{}'.format(uid),
'f2s/fuel_data', {
'uid': uid,
'env': env_id
},
tags=['node%s' % nobj.data['id']])
events = [
evapi.React(res.name, 'run', 'success', 'pre_deployment_start', 'run'),
evapi.React(res.name, 'update', 'success', 'pre_deployment_start',
'run')
]
evapi.add_events(res.name, events)
node = resource.load('node{}'.format(uid))
node.connect(res, {})
def connect_with_events(self,
receiver,
mapping=None,
events=None,
use_defaults=False):
mapping = get_mapping(self, receiver, mapping)
self._connect_inputs(receiver, mapping)
LogItem.new({
'resource': receiver.name,
'action': 'run',
'tags': receiver.tags
}).save_lazy()
# signals.connect(self, receiver, mapping=mapping)
# TODO: implement events
if use_defaults:
if self != receiver:
api.add_default_events(self, receiver)
if events:
api.add_events(self.name, events)
def connect(emitter, receiver, mapping=None, events=None):
# convert if needed
# TODO: handle invalid resource
# if isinstance(emitter, basestring):
# emitter = resource.load(emitter)
# if isinstance(receiver, basestring):
# receiver = resource.load(receiver)
mapping = mapping or guess_mapping(emitter, receiver)
if isinstance(mapping, set):
for src in mapping:
connect_single(emitter, src, receiver, src)
return
for src, dst in mapping.items():
if isinstance(dst, list):
for d in dst:
connect_single(emitter, src, receiver, d)
continue
connect_single(emitter, src, receiver, dst)
# possibility to set events, when False it will NOT add events at all
# setting events to dict with `action_name`:False will not add `action_name`
# event
events_to_add = [
Dependency(emitter.name, 'run', 'success', receiver.name, 'run'),
Dependency(emitter.name, 'update', 'success', receiver.name, 'update')
]
if isinstance(events, dict):
for k, v in events.items():
if v is not False:
events_to_add = filter(lambda x: x.parent_action == k, events_to_add)
add_events(emitter.name, events_to_add)
elif events is not False:
add_events(emitter.name, events_to_add)
def connect(emitter, receiver, mapping=None, events=None):
mapping = mapping or guess_mapping(emitter, receiver)
if isinstance(mapping, set):
mapping = {src: src for src in mapping}
for src, dst in mapping.items():
if not isinstance(dst, list):
dst = [dst]
for d in dst:
connect_single(emitter, src, receiver, d)
events_to_add = [
Dependency(emitter.name, "run", "success", receiver.name, "run"),
Dependency(emitter.name, "update", "success", receiver.name, "update"),
]
if isinstance(events, dict):
for k, v in events.items():
if v is not False:
events_to_add = filter(lambda x: x.parent_action == k, events_to_add)
add_events(emitter.name, events_to_add)
elif events is not False:
add_events(emitter.name, events_to_add)
def test_single_event(events_example):
r = Resource.from_dict(dict(key='e1', name='e1', base_path='x'))
r.save()
evapi.add_events('e1', events_example[:2])
evapi.add_event(events_example[2])
assert set(evapi.all_events('e1')) == set(events_example)
def test_single_event(events_example):
r = orm.DBResource(id='e1', name='e1', base_path='x')
r.save()
evapi.add_events('e1', events_example[:2])
evapi.add_event(events_example[2])
assert set(evapi.all_events('e1')) == set(events_example)
