def bd_sd_WCV1_models_get_CPV1(self, data, route_meta): model = self.get_model_from_table_name(data['obj_type']) sid = data['sid'] uuid = data['uuid'] cnt = data.get('cnt') per = data.get('per') if not cnt: cnt = 0 if not per or per > 30: per = 10 obj_type = data['obj_type'] obj_args = data.get('obj_args') args = None if obj_args: args = [ getattr(obj_class, key) == value for key, value in obj_args.items() ] objs_query = self.warehouse_db.session.query(model) if args: objs_query = objs_query.filter(*args) row_cnt = self.warehouse_db.session.query(model).count() offset = cnt * per objs = objs_query\ .offset(offset)\ .limit(per)\ .all() dicts = [self.warehouse_db.as_json(o) for o in objs] out = { 'action': 'data.rows.set', 'action_data': dicts, 'session_id': sid, 'uuid': uuid, } out1 = { 'action': 'data.rows.cnt.set', 'action_data': { 'cnt': row_cnt }, 'session_id': sid, 'uuid': uuid } msg = create_local_task_message('*****@*****.**', out) msg1 = create_local_task_message('*****@*****.**', out1) self.send_message_to_master(msg) self.send_message_to_master(msg1)
def connectionMade(self): self.connected = True print "Connection made {} my uuid: {}".format(self.transport.getPeer(), self.factory.driver.uuid) msg = create_local_task_message('*****@*****.**', {'uuid': self.factory.driver.uuid}) self.send(json.dumps(msg)) msg1 = create_local_task_message('*****@*****.**', {}) self.factory.driver.inbox.put(msg1, INBOX_SYS_CRIT_MSG)
def __init__(self, config): self.__exc_dir__ = config['exc_dir'] self.check_funcs = [[self.check_inbox, 0], [self.check_msg_timers, 1000]] print "Init BotDriver" self.__bd_command_mappings = { '@bd.echo': self.bd_echo, '@bd.comms.launch': self.bd_comms_launch, '@bd.process.kill': self.bd_process_kill, '@bd.watchdog.launch': self.bd_watchdog_launch, '@bd.heartbeat.pulse.send': self.bd_heartbeat_pulse_send, '@bd.outbox.add.front': self.bd_outbox_add_front, '@bd.die': self.bd_die, '@bd.error': self.bd_error, '@bd.instance.free': self.bd_instance_free, '@bd.taskrunner.inbox.add': self.bd_taskrunner_inbox_add } if not self.uuid: self.uuid = self.create_bot_uuid() self.msg_timers = [] self.heartbeat_pulse_interval = 10 self.add_command_mappings(self.__bd_command_mappings) msg = create_local_task_message('@bd.watchdog.launch', {}, { 'type': 'process', 'daemon': True }) wd_task = lambda: self.inbox.put(msg, INBOX_SYS_CRITICAL_MSG) self.init_start_task_funcs.append(wd_task) msg1 = create_local_task_message('@bd.heartbeat.pulse.send', {}) pulse_task = lambda: self.inbox.put(msg1, INBOX_SYS_MSG) self.init_start_task_funcs.append(pulse_task) msg2 = create_local_task_message('@bd.comms.launch', {}, {'type': 'process'}) comms_task = lambda: self.inbox.put(msg2, INBOX_SYS_MSG) self.init_start_task_funcs.append(comms_task) global driver driver = self
def add_local_task(self, route, data, priority=INBOX_TASK1_MSG, route_meta=None): msg = create_local_task_message(route, data, route_meta) self.inbox.put(msg, priority)
def bd_sd_slave_auth(self, data, route_meta): self.master_uuid = data['master_uuid'] print "Sending Authentication info to Master" msg = create_local_task_message('*****@*****.**', { 'uuid': self.uuid, 'model_id': self.model_id }) self.send_msg(msg, OUTBOX_SYS_MSG)
def send_message_to(self, uuid, msg, priority=OUTBOX_TASK_MSG): data = {'uuid': uuid, 'data': msg} out = create_local_task_message('*****@*****.**', data, origin=uuid) print "OUT MSG: {}".format(out) print "outbox obj:{}".format(self.outbox) self.outbox.put(out, priority)
def connected_to_master(self): print "CONNECTED_TO_MASTER!!!!\n\n\n" msg = create_local_task_message('[email protected]', {}) self.send_message_to_master(msg, OUTBOX_SYS_MSG) try: self.__set_isconnectedtomaster(True) except Exception as e: print "CONNECTED_TO_MASTER ERROR: {}".format(e)
def send_to_inbox(self, data): msg = None try: msg = create_local_task_message(data['route'], data['data'], data['route_meta']) except TypeError as e: print "\n\n\n\TypeError comms.client: {}".format(e) print "error with {}:\n{}\n".format(type(data), data) raise e else: self.factory.driver.inbox.put(msg, INBOX_SYS_MSG)
def send_it(self, payload): if hasattr(self, 'p'): print "Sending to master..." if type(payload) == dict: payload = json.dumps(payload) self.p.send(payload) else: msg1 = create_local_task_message('*****@*****.**', {}) self.driver.inbox.put(msg1, INBOX_SYS_CRIT_MSG)
def user_login(): data = request.get_json(force=True) sdata = {'username': data['username'], 'password': data['password']} tag = driver.taskrunner_create_address_tag() sdata['tag'] = tag msg = create_local_task_message('*****@*****.**', sdata) driver.send_message_to_master(msg) d = driver.taskrunner_inbox_get_tag(tag, poll=5, delay=.5) print "GOT THIS SHIT FROM DATA: {}\n\n\n".format(d) return json.dumps(d)
def connectionLost(self, reason): print '</> (Lost {}) bc: {}'.format(self.uuid, reason) if self.uuid in self.factory.connections.keys(): #delete uuid from connections try: driver.inbox.put( create_local_task_message('*****@*****.**', {'uuid': self.uuid}), 0) except: pass finally: del self.factory.connections[self.uuid]
def on_getall(data): emit('SET_SID', {'sid': request.sid}, namespace='/', room=request.sid) emit('set_last_update', {'last_update': last_update}, namespace='/', room=request.sid) if not master_is_connected: msg = create_local_task_message( '[email protected]', {}) driver.inbox.put(msg, INBOX_SYS_MSG) else: socketio.emit('set_is_connected_to_master', {'is_connected': master_is_connected}, namespace='/', room=request.sid) global uuid d = {'uuid': uuid, 'sid': request.sid} msg = create_local_task_message('*****@*****.**', d) driver.send_msg(msg, 0) print "\n\n**********************GETALL!!, last_UPDATE: {}".format( last_update)
def func_execute(self, func, data, route_meta): #ASsign global task instance variables self.RUNNING_GLOBAL_TASK = True keys = route_meta.keys() if 'task_id' in keys: self.task_id = route_meta['task_id'] if 'job_id' in keys: self.job_id = route_meta['job_id'] func(data, route_meta) msg = create_local_task_message('@bd.instance.free', {}) self.inbox.put(msg, INBOX_SYS_MSG)
def taskrunner_send_data_to_tag(self, tag, data, uuid=None): if not uuid: uuid = self.taskrunner_address_tag_get_uuid(tag) if uuid and uuid != self.uuid: msg = create_local_task_message('@bd.taskrunner.inbox.add', { 'tag': tag, 'tdata': data }) self.send_message_to(uuid, msg) return self.taskrunner_inbox_add(tag, data)
def on_forward(data): global cpv1_cmd_id cpv1_cmd_id += 1 if 'cmd_msg' in data.keys(): #data['cmd_msg'] = data['cmd_msg']+' [{}]'.format(cpv1_cmd_id) pass data['sid'] = set_sid_info(request.sid, cpv1_cmd_id) global uuid data['uuid'] = uuid msg = create_local_task_message('*****@*****.**', data) driver.send_msg(msg, 0) print "\n*******\nFORWARD DATA: {}".format(data)
def send_cmd_msg(self, cmd_id, resp, session_id=None, uuid=None): print "CPV1.slave.SEND_CMD_MSG" cmd_msg = self.get_cmd_msg(cmd_id) if cmd_msg: print "FOUND MSG" cmd_msg = "{}: {}".format(resp, cmd_msg) data['msg'] = cmd_msg if session_id: data['session_id'] = session_id if uuid: data['uuid'] = uuid msg = create_local_task_message('*****@*****.**', data) self.send_msg(msg)
def starting_global_task(self, data, route_meta): task_id = route_meta['task_id'] task_msg = create_local_task_message( '*****@*****.**', { 'task_id': task_id, 'time_started': str(datetime.utcnow()) }) self.send_message_to_master(task_msg) print 'Starting Global Task id {}'.format(task_id) route = data['route'] route_data = data['data'] err, msg = self.router(route, json.loads(route_data), route_meta) task_msg1 = None if err: task_msg1 = create_local_task_message('*****@*****.**', { 'task_id': task_id, 'msg': msg }) print 'Error Global Task id {}'.format(task_id) else: task_msg1 = create_local_task_message( '*****@*****.**', { 'task_id': task_id, 'time_completed': str(datetime.utcnow()) }) print 'Completed Global Task id {}'.format(task_id) self.send_message_to_master(task_msg1) free_msg = create_local_task_message('@bd.instance.free', {}) self.inbox.put(free_msg, INBOX_SYS_MSG)
def send_it(self, payload): uuid = payload['uuid'] data = None if type(payload) == dict: data = json.dumps(payload['data']) try: self.connections[uuid].send(data) except KeyError: self.driver.inbox.put( create_local_task_message('*****@*****.**', {'uuid': uuid}), 0) if uuid in self.connections.keys(): del self.connections[uuid] print "\n\ncomms.server UUID: {} DOESNT EXIST AS CONNECTION".format( uuid)
def send_to_inbox(self, data): priority = INBOX_SYS_MSG if data['route'] == '*****@*****.**': #create seperate func self.uuid = data['data']['uuid'] self.factory.connections[data['data']['uuid']] = self elif data['route'] == '*****@*****.**': priority = INBOX_SYS_CRIT_MSG else: if not self.uuid: self.transport.abortConnection() print "\n\nSLAVE IS NOT REGISTER DISCONNECTING: {} comms.server\n\n".format( self.uuid) return data['route_meta']['origin'] = self.uuid msg = create_local_task_message(data['route'], data['data'], data['route_meta']) driver.inbox.put(msg, priority)
def bd_sd_CPV1_server_run(self, data, route_meta): #Add to to watchdogs to be deleted msg = create_local_task_message('[email protected]', {}) self.send_message_to_master(msg) global uuid uuid = self.uuid pid = os.getpid() print "\n\n\nRunning webserver {}".format(pid) self.heartbeat.__track_process__(pid, name='CPV1 Webserver', route='*****@*****.**', data=data) thread = threading.Thread(target=self.server_pulse_loop, args=(pid, )) thread.daemon = True #False thread.start() ###KEeps running even when server fails #socketio.start_background_task(self.server_pulse_loop, pid) debug = False if 'CPV1_debug' in self.config.keys(): if self.config['CPV1_debug']: self.report_error( 'NotImplemented', "Config Key CPV1_debug is not setup correctly", kill=True) debug = True try: socketio.run(app, host=data['host'], port=data['port'], debug=debug) except Exception as e: print "\n\nWEBSERVER CPV1 broke" self.report_error('CPV1 Webserver fail', str(e), kill=True) sys.exit(0)
def reject_global_task(self, task_id, job_id): msg = create_local_task_message('*****@*****.**', { 'task_id': task_id, 'job_id': job_id }) self.send_message_to_master(msg)
def connectionLost(self, s): self.connected = False print "connection lost" msg1 = create_local_task_message('*****@*****.**', {}) self.factory.driver.inbox.put(msg1, INBOX_SYS_CRIT_MSG)
def send_pulse_to_master(self): if self.uuid: data = {'uuid': self.uuid} out = create_local_task_message('*****@*****.**', data) self.send_message_to_master(out)
def bd_sd_task_global_stop(self, data, route_meta): if data['task_id'] == self.running_instance_task_id: print "Stopping task id {}".format(self.running_instance_task_id) self.bd_instance_free({}, route_meta) out = create_local_task_message('*****@*****.**', {}) self.send_message_to_master(out)
def on_get(data): global uuid data['uuid'] = uuid data['sid'] = request.sid msg = create_local_task_message('*****@*****.**', data) driver.send_msg(msg, 0)