def login_handler(msg): user = msg.body id = vertx.config()['user-prefix'] + str(uuid.uuid4()) users.add(user) EventBus.register_handler(id, handler=lambda msg: command_handler(user, msg)) EventBus.publish(vertx.config()['users-address'], user) msg.reply({'id': id, 'users': list(users)})
def register_method(message): address = message.body.get("address", None) method = message.body.get("method", None) module = message.body.get("module", None) if (address != None and method != None and module != None): EventBus.register_handler(address, "%s.%s"% (module,method)) else: message.reply("register_method missing address or method or module")
def start(self): #self.eventBus.registerHandler(self.address, self); self.config = VertxLocator.container.getConfig() self.engine = create_engine(self.db_path, echo=False) self.Session = sessionmaker(bind=self.engine) EventBus.register_handler(self.address, handler=self.handle) self.metadata.create_all(self.engine)
def register(self): def handler(msg): if not msg.body.has_key('error'): headers = { 'Authorization': 'token '+msg.body['access_token'] } get('https://api.github.com/user', handle_response, headers=headers) if 'email' in msg.body['scope']: pass else: logger.error(msg.body) EventBus.register_handler('auth.github.login', handler=handler)
def test_deploy(self): def handler(message): if message.body == "started": tu.test_complete() EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} def deploy_handler(err, ok): tu.azzert(err == None) vertx.deploy_verticle("core/deploy/child.py", conf, 1, deploy_handler)
def test_deploy(self): def handler(message): if message.body == "started": tu.test_complete() EventBus.register_handler("test-handler", False, handler) conf = {'foo': 'bar'} def deploy_handler(err, ok): tu.azzert(err == None) vertx.deploy_verticle("core/deploy/child.py", conf, 1, deploy_handler)
def test_send_unregister_send(self): json = {'message': 'hello world!'} address = "some-address" self.received = False def handler(msg): if self.received: tu.azzert(False, "handler already called") tu.azzert(msg.address == address) tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(id) self.received = True def timer_complete(id): tu.test_complete() # End test on a timer to give time for other messages to arrive vertx.set_timer(100, timer_complete) id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) for i in range(0, 2): EventBus.send(address, json)
def echo(self, msg): address = "some-address" #print "The message is %s type %s"% (msg, type(msg)) class Handler(object): def handler_func(self, received): #print "received: %s type %s"% type(received.body, type(received.body)) tu.check_context() EventBus.unregister_handler(self.id) received.reply(received.body) handler = Handler() handler.id = EventBus.register_handler(address, handler=handler.handler_func) def reply_handler(reply): #print "received reply %s type %s"% (reply.body, type(reply.body)) if isinstance(reply.body, dict): for k, v in reply.body.iteritems(): tu.azzert(msg[k] == v) else: tu.azzert(msg == reply.body) tu.test_complete() EventBus.send(address, msg, reply_handler)
def test_reply_of_reply_of_reply(self): address = "some-address" def handler(msg): tu.azzert("message" == msg.body) def reply_handler1(reply): tu.azzert("reply-of-reply" == reply.body) reply.reply("reply-of-reply-of-reply") msg.reply("reply", reply_handler1) id = EventBus.register_handler(address, handler=handler) def reply_handler2(reply): tu.azzert("reply" == reply.body) def reply_handler3(reply2): tu.azzert("reply-of-reply-of-reply" == reply2.body) EventBus.unregister_handler(id) tu.test_complete() reply.reply("reply-of-reply", reply_handler3) EventBus.send(address, "message", reply_handler2)
def test_deploy(self): global handler_id def handler(message): if message.body == "started": tu.test_complete() handler_id = EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} vertx.deploy_verticle("core/deploy/child.py", conf)
def get_auth_uid(uid): if (uid.body == None): message.reply(None) else: userID = uid.body get_user_eb = EventBus.register_handler("get_user_private", handler = get_user) def user_handler(user): message.reply(user.body) EventBus.unregister_handler(get_user_eb) EventBus.send("get_user_private", {"userID":userID}, user_handler)
def test_undeploy(self): print "in test undeploy" def handler(message): return EventBus.register_handler("test-handler", False, handler) conf = {'foo' : 'bar'} def undeploy_handler(err): tu.azzert(err == None) tu.test_complete() def deploy_handler(err, id): tu.azzert(err == None) vertx.undeploy_verticle(id, handler=undeploy_handler) vertx.deploy_verticle("core/deploy/child.py", conf, handler=deploy_handler)
def test_send_empty(self): json = {} address = "some-address" def handler(msg): tu.azzert(msg.body == {}) EventBus.unregister_handler(id) tu.test_complete() id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) EventBus.send(address, json)
def __init__(self, cfg, creds): self.id = cfg['id'] self.cfg = cfg self.client = self._build_client(cfg, creds) self.address = "hbdriver:client:" + self.id self._handlers = [] for addr, h in [(self.address, self.handler), (self.STATUS_ADDRESS, self.status_handler), (self.SHUTDOWN_ADDRESS, self.shutdown_handler)]: hid = EventBus.register_handler(addr, handler=h) self._handlers.append(hid)
def test_simple_send(self): json = {'message' : 'hello world!'} address = "some-address" def handler(msg): tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(id) tu.test_complete() id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) EventBus.send(address, json)
def test_undeploy(self): print "in test undeploy" def handler(message): return EventBus.register_handler("test-handler", False, handler) conf = {'foo': 'bar'} def undeploy_handler(err): tu.azzert(err == None) tu.test_complete() def deploy_handler(err, id): tu.azzert(err == None) vertx.undeploy_verticle(id, handler=undeploy_handler) vertx.deploy_verticle("core/deploy/child.py", conf, handler=deploy_handler)
def test_simple_send(self): json = {'message': 'hello world!'} address = "some-address" def handler(msg): tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(id) tu.test_complete() id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) EventBus.send(address, json)
def test_reply_timeout(self): json = {'message': 'hello world!'} address = 'some-address' reply = {'cheese': 'stilton!'} def handler(msg): tu.azzert(msg.body['message'] == json['message']) id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) def reply_handler(error, msg): tu.azzert(error != None) EventBus.unregister_handler(id) tu.test_complete() EventBus.send_with_timeout(address, json, 10, reply_handler)
def test_reply(self): json = {'message' : 'hello world!'} address = "some-address" reply = {'cheese' : 'stilton!'} def handler(msg): tu.azzert(msg.body['message'] == json['message']) msg.reply(reply) id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) def reply_handler(msg): tu.azzert(msg.body['cheese'] == reply['cheese']) EventBus.unregister_handler(id) tu.test_complete() EventBus.send(address, json, reply_handler)
def test_empty_reply(self): json = {'message': 'hello world!'} address = "some-address" reply = {} def handler(msg): tu.azzert(msg.body['message'] == json['message']) msg.reply(reply) id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) def reply_handler(msg): tu.azzert(msg.body == {}) EventBus.unregister_handler(id) tu.test_complete() EventBus.send(address, json, reply_handler)
def echo(self, msg): address = "some-address" class Handler(object): def handler_func(self, received): tu.check_thread() EventBus.unregister_handler(self.id) received.reply(received.body) handler = Handler() handler.id = EventBus.register_handler(address, handler=handler.handler_func) def reply_handler(reply): if isinstance(reply.body, dict): for k,v in reply.body.iteritems(): tu.azzert(msg[k] == v) else: tu.azzert(msg == reply.body) tu.test_complete() EventBus.send(address, msg, reply_handler)
def websocket_handler(socket): def getUUID(): s = socket.toString() return s.split('@')[-1] uuid = getUUID() def send_mycommand(data, reply=None): message = {'uuid': uuid, 'message': data} if reply == None: EventBus.send('send.mycommand', message) else: EventBus.send('send.mycommand', message, reply) @socket.data_handler def data_handler(buff): resp_data = '%r' % buff send_mycommand(resp_data) print 'input:', resp_data if socket.write_queue_full: socket.pause() @socket.drain_handler def drain_handler(): socket.resume() @socket.close_handler def close_handler(): def closing(msg): EventBus.unregister_handler(resultHandleId) send_mycommand('clear', closing) print 'closed websocket', uuid def receive_result(msg): socket.write_text_frame(str(msg.body)) resultHandleId = EventBus.register_handler('receive.myresult' + uuid, handler=receive_result) #send_mycommand('') print 'hello websocket', uuid
def test_send_multiple_matching_handlers(self): json = {'message' : 'hello world!'} address = "some-address" num_handlers = 10 count = [0] # use an array to ensure pass by ref for i in range(0,num_handlers): class Handler(object): def __init__(self, count): self.count = count def handler_func(self, msg): tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(self.id) self.count[0] += 1 if self.count[0] == num_handlers: tu.test_complete() handler = Handler(count) handler.id = EventBus.register_handler(address, handler=handler.handler_func) EventBus.publish(address, json)
def websocket_handler(socket): def getUUID(): s = socket.toString() return s.split('@')[-1] uuid = getUUID() def send_mycommand(data,reply=None): message = {'uuid':uuid,'message':data} if reply == None: EventBus.send('send.mycommand',message) else: EventBus.send('send.mycommand',message,reply) @socket.data_handler def data_handler(buff): resp_data = '%r'%buff send_mycommand(resp_data) print 'input:',resp_data if socket.write_queue_full: socket.pause() @socket.drain_handler def drain_handler(): socket.resume() @socket.close_handler def close_handler(): def closing(msg): EventBus.unregister_handler(resultHandleId) send_mycommand('clear',closing) print 'closed websocket',uuid def receive_result(msg): socket.write_text_frame(str(msg.body)) resultHandleId = EventBus.register_handler('receive.myresult'+uuid,handler=receive_result) #send_mycommand('') print 'hello websocket',uuid
def echo(self, msg): address = "some-address" #print "The message is %s type %s"% (msg, type(msg)) class Handler(object): def handler_func(self, received): #print "received: %s type %s"% type(received.body, type(received.body)) tu.check_context() EventBus.unregister_handler(self.id) received.reply(received.body) handler = Handler() handler.id = EventBus.register_handler(address, handler=handler.handler_func) def reply_handler(reply): #print "received reply %s type %s"% (reply.body, type(reply.body)) if isinstance(reply.body, dict): for k,v in reply.body.iteritems(): tu.azzert(msg[k] == v) else: tu.azzert(msg == reply.body) tu.test_complete() EventBus.send(address, msg, reply_handler)
def echo(self, msg): address = "some-address" class Handler(object): def handler_func(self, received): tu.check_thread() EventBus.unregister_handler(self.id) received.reply(received.body) handler = Handler() handler.id = EventBus.register_handler(address, handler=handler.handler_func) def reply_handler(reply): if isinstance(reply.body, dict): for k, v in reply.body.iteritems(): tu.azzert(msg[k] == v) else: tu.azzert(msg == reply.body) tu.test_complete() EventBus.send(address, msg, reply_handler)
def test_send_unregister_send(self): json = {'message' : 'hello world!'} address = "some-address" self.received = False def handler(msg): if self.received: tu.azzert(False, "handler already called") tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(id) self.received = True def timer_complete(id): tu.test_complete() # End test on a timer to give time for other messages to arrive vertx.set_timer(100, timer_complete) id = EventBus.register_handler(address, handler=handler) tu.azzert(id != None) for i in range(0,2): EventBus.send(address, json)
def test_send_multiple_matching_handlers(self): json = {'message': 'hello world!'} address = "some-address" num_handlers = 10 count = [0] # use an array to ensure pass by ref for i in range(0, num_handlers): class Handler(object): def __init__(self, count): self.count = count def handler_func(self, msg): tu.azzert(msg.body['message'] == json['message']) EventBus.unregister_handler(self.id) self.count[0] += 1 if self.count[0] == num_handlers: tu.test_complete() handler = Handler(count) handler.id = EventBus.register_handler( address, handler=handler.handler_func) EventBus.publish(address, json)
import vertx from core.event_bus import EventBus config = vertx.config() event_bus_address = config['address'] output_address = config['output_address'] def msg_handler(message): #actual received data data = message.body #turn the raw bytes into some text text = data.tostring() #pass along to output handler EventBus.send(output_address, text) id = EventBus.register_handler(event_bus_address, handler=msg_handler)
import vertx from core.event_bus import EventBus config = vertx.config() event_bus_address = config['address']; output_address = config['output_address']; def msg_handler(message): #actual received data data = message.body; #turn the raw bytes into some text text = data.tostring() #pass along to output handler EventBus.send(output_address,text); id = EventBus.register_handler(event_bus_address, handler=msg_handler)
def __init__(self, credentials, address=ADDRESS): self._pool = list(credentials) self._inuse = {} EventBus.register_handler(address, handler=self.handle)
# Copyright 2011 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import vertx from core.event_bus import EventBus def handler(msg): print 'Received news %s' % msg.body EventBus.register_handler('news-feed', handler=handler)
def _wrapper(func): EventBus.register_handler(addr, handler=func) return func
# Copyright 2011 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import vertx from core.event_bus import EventBus def handler(msg): print 'Received message %s' % msg.body # Now reply to it msg.reply('Pong!') EventBus.register_handler('ping-address', handler=handler)
#the_flight.putString("planeType", flight.getString("equipment") ) the_flight.putString("speed", flight.get("properties").get("direction")) the_flight.putString("alt", flight.get("properties").get("route")) position_array = flight.get("geometry").get("coordinates") #print position_array #There can sometimes be two positions readings but I am not sure what they do so I am just going to take the first #position = position_array[0] the_flight.putNumber("lat", position_array[1]) the_flight.putNumber("lon", position_array[0]) #build the object to persist to mongo forMongo = JsonObject() forMongo.putString("action", "save") forMongo.putString("collection", "buses") forMongo.putObject("document", the_flight) #persist it EventBus.publish('vertx.mongopersistor', forMongo) #add now to the array flights.addObject(the_flight) #Sent the array on the EventBus - this is the one the page should subscribe to EventBus.publish('flights.updated', flights) print("published the flights") EventBus.register_handler('raw.flights', handler=handler)
# Copyright 2011 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import vertx from core.event_bus import EventBus def handler(msg): print 'Subscriber verticle received msg : %s' % msg.body['body'] EventBus.register_handler('foo-bar', handler=handler)
from com.xhaus.jyson import JysonCodec as json from oauth import Consumer from core.event_bus import EventBus from util import parse_date from datetime import datetime, timedelta config = vertx.config() curators = [] friends = [] aday = datetime.now() - timedelta(1) def response_handler(resp, user_id): favs = {'user_id': user_id, 'favorites': []} @resp.body_handler def body_handler(body): if resp.status_code == 200: favs['favorites'] = json.loads(body.to_string()) else: print "Failed to fetch favorites: %s" % body.to_string() EventBus.send('log.event', "user.favorites.list.result") EventBus.send('user.favorites.list.result', json.dumps(favs)) def fetch_favorites(message): user = message.body consumer = Consumer(api_endpoint="https://api.twitter.com/", consumer_key=config['consumer_key'], consumer_secret=config['consumer_secret'], oauth_token=config['oauth_token'], oauth_token_secret=config['oauth_token_secret']) consumer.get("/1.1/favorites/list.json", {'user_id': user['id'], 'count': 20}, lambda resp: response_handler(resp, user['id'])) EventBus.register_handler('user.favorites.list', False, fetch_favorites)
public_actions = { "api": { "bus_utils": { "simple_search":"simple_search", "registration":"registration", } } } def register_(public_actions): for package in public_actions: for module in package: #TODO IMPORT HERE for action in module: def reply(msg): logger.info(msg.body) EventBus.send("register_method",{"address:action","method":method,"module":module}, reply) #{address,method,package} def register_method(message): address = message.body.get("address", None) method = message.body.get("method", None) module = message.body.get("module", None) if (address != None and method != None and module != None): EventBus.register_handler(address, "%s.%s"% (module,method)) else: message.reply("register_method missing address or method or module") register_method = EventBus.register_handler("register_method", handler= register_method)
import vertx from core.event_bus import EventBus config = vertx.config() client = vertx.create_http_client() client.port = config['remote_port'] client.host = config['remote_host'] def command_response(resp): '''response of send command to analyzer ''' @resp.body_handler def receive(buff): pass def command_request(msg): '''send command to analyzer ''' msg.reply('') send_data = msg.body.get('message') args = '?uuid=%s'%msg.body.get('uuid') request = client.post('/myconsole'+args, command_response) request.put_header('Content-Length',str(len(send_data))) request.write_str(send_data) request.end() EventBus.register_handler('send.mycommand',handler=command_request)
if (email == None): EventBus.send(smtp_address, {"from": "*****@*****.**","to": to, "subject":subject,"body":body}, reply_status) else: def reply_handler(msg): logger.info("save email %s %s"% (message.body,msg.body)) EventBus.send('vertx.mongopersistor', {'action': 'save', 'collection': 'emails',"document": message.body}, reply_handler) EventBus.send(smtp_address, {"from": "*****@*****.**","to": to, "subject":subject,"body":body}, reply_status) #public #{user} #TODO template def registration_mail(message): user = message.body.get("user", None) if (user == None): message.reply("user not specifed") else: mail = { "to": user.get("email"), "body": "Thank you for registration %s please follow http://master.majklk.cz"% user.get("username"), "subject": "registration filehosting" } def reply(msg): message.reply(msg.body) #TODO rich reply EventBus.send("send_mail",mail,reply) #TODO LINK MAIL #TODO FORGOT PASS MAIL #TODO propagation upstairs #send_mail = EventBus.register_handler("send_mail", handler = send_mail) registration_mail = EventBus.register_handler("registration_mail", handler = registration_mail)
import vertx import os from core.event_bus import EventBus def myHandler(message): finalPath = message.body['destinationFilePath'] command= ("convert -scale 10% -scale 1000% " + message.body['originalFilePath'] + " " + finalPath) os.system(command) EventBus.send("image.processing.completed",{'updatedName':message.body['updatedName'],'name':message.body['name']}) print finalPath +" ::Finished" print "------------------------------------------" EventBus.register_handler('image.transform.pixelate', handler=myHandler)
def _on_credentials(cmsg): if cmsg.body['status'] == 200: client = HBCAgent(cfg, cmsg.body['credentials']) client.start() msg.reply(dict(status=200, clientAddress=client.address)) else: msg.reply(dict(status=500, msg="Failure to acquire credentials", cause=cmsg.body)) EventBus.send(CredentialManager.ADDRESS, dict(command="acquire", id=cfg['id']), _on_credentials) EventBus.register_handler('hbdriver:start', handler=start_stream) def init_controller(config): if config.get('webserver') is not None: start_server(config['webserver']) def init_credmgr(config): mgr = CredentialManager([]) for cfg in config.get("credentials") or []: mgr.add(cfg) key = config.get("credentialsEnvVar") if not key: return try:
# coding=utf-8 """ Re-tweetet tweets @author Markus Tacker <*****@*****.**> """ import vertx from oauth import Consumer from core.event_bus import EventBus from com.xhaus.jyson import JysonCodec as json config = vertx.config() def response_handler(resp): @resp.body_handler def body_handler(body): if resp.status_code == 200: data = json.loads(body.to_string()) print "Retweeted https://twitter.com/%s/status/%d" % (data['retweeted_status']['user']['screen_name'], data['retweeted_status']['id']) else: print "ERROR! " + body.to_string() def create_retweet(message): consumer = Consumer(api_endpoint="https://api.twitter.com/", consumer_key=config['consumer_key'], consumer_secret=config['consumer_secret'], oauth_token=config['oauth_token'], oauth_token_secret=config['oauth_token_secret']) consumer.post("/1.1/statuses/retweet/%d.json" % message.body, None, response_handler) EventBus.register_handler('retweet.create', False, create_retweet)
def event_bus_reg(self): if EventBus: EventBus.register_handler( self.DEF_EVENT_BUS_EPC_Rx_CALLBACK_ADDRESS, handler=rx_callback_handler)
fetching = mutex.mutex() def response_handler(resp): # TODO: Error handling # print "got response %s" % resp.status_code # print resp.headers @resp.body_handler def body_handler(body): global curators if resp.status_code == 200: data = json.loads(body.to_string()) curators = [] for user in data['users']: curators.append({'screen_name': user['screen_name'], 'id': user['id']}) fetching.unlock() EventBus.send('log.event', "curators.list.result") EventBus.send('curators.list.result', json.dumps(curators)) def list_curators(message): global fetching if curators is None: if not fetching.testandset(): return consumer = Consumer(api_endpoint="https://api.twitter.com/", consumer_key=config['consumer_key'], consumer_secret=config['consumer_secret'], oauth_token=config['oauth_token'], oauth_token_secret=config['oauth_token_secret']) consumer.get("/1.1/lists/members.json", {'slug': config['curatorslist'], 'owner_screen_name': config['account']}, response_handler) else: EventBus.send('log.event', "curators.list.result (Cached)") EventBus.send('curators.list.result', json.dumps(curators)) EventBus.register_handler('curators.list', False, list_curators)
import vertx from core.event_bus import EventBus def handler(msg): msg.reply("pong!") print "sent back pong Python!" EventBus.register_handler("ping-address", handler=handler)
else: message.reply(None) EventBus.send("local.authorize", {"sessionID":message.body.get("sessionID")}, authorize_handler) #PRIVATE def get_file_from_db(message): fileID = message.body.get("fileID", None) def reply_handler(msg): file_props = msg.body.get("result", None) if (file_props == None): message.reply(None) elif (file_props != None): message.reply(file_props) else: logger.info("get_file_from_db error in result" ) EventBus.send('vertx.mongopersistor', {'action': 'findone', 'collection': 'files', 'matcher': {"_id":fileID}}, reply_handler) EventBus.register_handler("get_file_from_db", handler = get_file_from_db) def get_file(message): sessionID = message.body.get("sessionID", None) fileID = message.body.get("fileID", None) if (sessionID != None and fileID != None): def authorize_handler(msg): if (msg.body != None): def get_user_id(uid): if (uid.body != None): def reply_handler(msg): logger.info(msg.body) if msg.body != None: message.reply(msg.body) else: message.reply(None) EventBus.send("get_file_from_db",{"fileID":fileID},reply_handler)
""" Startet die App @author Markus Tacker <*****@*****.**> """ import vertx from core.event_bus import EventBus def log_event(message): print ">> %s" % message.body EventBus.register_handler('log.event', False, log_event) config = vertx.config() vertx.deploy_verticle("fetchcurators.py", config) vertx.deploy_verticle("fetchfavorites.py", config) vertx.deploy_verticle("fetchfriends.py", config) vertx.deploy_verticle("fetchfavorites.py", config) vertx.deploy_verticle("createfavorite.py", config) vertx.deploy_verticle("createretweet.py", config) vertx.deploy_verticle("publishretweets.py", config)