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)