def populate_routing_table(routing_entries):
routing_table = RoutingTable()
for entry in routing_entries:
source, target = entry['source'], entry['target']
src_conn, src_endp = EndpointType.parse_uuid(
source['uuid'])
dst_conn, dst_endp = EndpointType.parse_uuid(
target['uuid'])
routing_table.add_entry(src_conn, src_endp, dst_conn, dst_endp)
d = user_api.get_user_account()
d.addCallback(save_routing_table, routing_table)
return d
def _set_routing_table(self, user, entries):
# Each entry is a tuple of (src, dst) where src and dst are
# conversations, tags or connector strings.
routing_table = RoutingTable()
user.routing_table = routing_table
def mkconn(thing):
if isinstance(thing, basestring):
return GoConnector.parse(thing)
else:
# Assume it's a conversation/channel/router.
return thing.get_connector()
for src, dst in entries:
routing_table.add_entry(mkconn(src), "default", mkconn(dst),
"default")
def _set_routing_table(self, user, entries):
# Each entry is a tuple of (src, dst) where src and dst are
# conversations, tags or connector strings.
routing_table = RoutingTable()
user.routing_table = routing_table
def mkconn(thing):
if isinstance(thing, basestring):
return GoConnector.parse(thing)
else:
# Assume it's a conversation/channel/router.
return thing.get_connector()
for src, dst in entries:
routing_table.add_entry(
mkconn(src), "default", mkconn(dst), "default")
def assert_routing_table(self, channel_conv=[], channel_router=[],
router_conv=[]):
"""Assert that the routing table has a particular form.
:param tag_conv: List of (tag, conversation) pairs.
:param tag_router: List of (tag, router) pairs.
:param router_conv: List of (router, endpoint, conversation) triples.
"""
rt = RoutingTable()
for channel, conv in channel_conv:
channel_conn = channel.get_connector()
conv_conn = conv.get_connector()
rt.add_entry(channel_conn, 'default', conv_conn, 'default')
rt.add_entry(conv_conn, 'default', channel_conn, 'default')
for channel, router in channel_router:
channel_conn = channel.get_connector()
rin_conn = router.get_inbound_connector()
rt.add_entry(channel_conn, 'default', rin_conn, 'default')
rt.add_entry(rin_conn, 'default', channel_conn, 'default')
for router, endpoint, conv in router_conv:
rout_conn = router.get_outbound_connector()
conv_conn = conv.get_connector()
rt.add_entry(rout_conn, endpoint, conv_conn, 'default')
rt.add_entry(conv_conn, 'default', rout_conn, endpoint)
self.assertEqual(self.user_helper.user_api.get_routing_table(), rt)
def setup_routing(self, user, account_objects):
connectors = {}
for conv in account_objects['conversations']:
connectors[conv['key']] = GoConnector.for_conversation(
conv['conversation_type'], conv['key'])
for tag in account_objects['channels']:
connectors[tag] = GoConnector.for_transport_tag(*(tag.split(':')))
for router in account_objects['routers']:
connectors[router['key'] + ':INBOUND'] = GoConnector.for_router(
router['router_type'], router['key'], GoConnector.INBOUND)
connectors[router['key'] + ':OUTBOUND'] = GoConnector.for_router(
router['router_type'], router['key'], GoConnector.OUTBOUND)
rt = RoutingTable()
for src, src_ep, dst, dst_ep in account_objects['routing_entries']:
rt.add_entry(
str(connectors[src]), src_ep, str(connectors[dst]), dst_ep)
user_account = vumi_api_for_user(user).get_user_account()
user_account.routing_table = rt
user_account.save()
self.stdout.write('Routing table for %s built\n' % (user.email,))