def create(self, channelName, uid, appName, password = None, masterPwd = None, forceJoin=True):
"""Return: Ajoute un channel a la liste des rooms -> bool"""
import random
from commons.session import Session
if appName not in self.applications:
self.applications[appName] = []
if self.chanExists(channelName=channelName, appName=appName) == False:
client = Session().get(uid)
client.room_name = channelName
channel = Channel(channelName)
if masterPwd is None:
channel.master_password = random.getrandbits(16)
else:
channel.master_password = masterPwd
if forceJoin is True:
channel.add(uid, channel.master_password)
if password is not None:
channel.password = password
self.applications[appName].append({
'name': channelName,
'channel': channel,
'app': appName
})
return True
#self.applications.pop(appName)
return False
def __sendMessage(self, channelName, appName, sender, to, message):
"""Fromate le json, et envoie le message a l'utilisateur"""
from commons.session import Session
sender = Session().get(sender)
receiver = Session().get(to)
json = Protocol.forgeJSON('message', '["' + sender.getName() + '", "' + message + '"]',
{'channel': channelName, 'app': appName})
if receiver is not None:
receiver.addResponse(json)
def workflow(src_conn_id, src_schema, dt, target_conn_id, target_table):
# TODO Split code into functions
etl_conn = PostgresHook(postgres_conn_id='etl').get_conn()
with Session(etl_conn, f'{dag.dag_id}__{src_schema}') as session:
# Load data
source_conn = MsSqlHook(mssql_conn_id=src_conn_id,
schema=src_schema).get_conn()
query = f"""
SELECT
id, start_time, end_time, type, data
FROM dbo.Orders
WHERE
CONVERT(DATE, start_time) = '{dt}'
"""
df = pd.read_sql_query(query, source_conn)
# Skip if no rows
if df.empty:
raise AirflowSkipException('No rows to load')
# Add service fields
df['etl_source'] = src_schema
df['etl_id'] = session.id
df['hash_id'] = hash_pandas_object(df[['etl_source', 'id']])
# Export data to CSV buffer
buffer = StringIO()
df.to_csv(buffer,
index=False,
sep='|',
na_rep='NUL',
quoting=csv.QUOTE_MINIMAL,
header=False,
float_format='%.8f',
doublequote=False,
escapechar='\\')
buffer.seek(0)
# Push CSV
target_conn = VerticaHook(vertica_conn_id=target_conn_id).get_conn()
copy_stmt = f"""
COPY {target_table}({df.columns.to_list()})
FROM STDIN
DELIMITER '|'
ENCLOSED '"'
ABORT ON ERROR
NULL 'NUL'
"""
cursor = target_conn.cursor()
cursor.copy(copy_stmt, buffer)
session.loaded_rows = cursor.rowcount
session.successful = True
def __cmd_httpSendMessage(self, args):
params = args.get('args', None)
if params is not None:
password = params.get('adminPwd', None)
if password == SETTINGS.MASTER_PASSWORD:
from commons.session import Session
for item in params.get('to'):
sess = Session().get(str(item))
if sess:
json = Protocol.forgeJSON('message',
'["system", "%s"]' %
(params.get('message',
'')),
{'channel': 'system',
'app': 'system'})
sess.addResponse(json)
return ('true')
return ('false')
def getData(self, uid, get=False):
"""
Recupere les reponses en suspend de l'utilisateur via son UID et
les revoie separees par des \n
"""
client = Session().get(uid)
if client is None:
return ''
responses = client.getResponse()
response = ''
for res in responses:
if '"connected"' not in res:
if get is True:
response += "%s%s%s" % (ClientHTTP.pre_get,
str(res), ClientHTTP.post_get)
else:
response += "%s\n" % str(res)
if len(response) > 0:
Log().add('[http] Send: %s' % response)
return response
def status(self, client, appName, channelName):
from log.logger import Log
from commons.session import Session
master = False
if self.chanExists(channelName=channelName, appName=appName):
channel = self.Channel(channelName, appName)
if channel and client.unique_key in channel.masters():
master = True
key = client.unique_key
name = client.getName()
to_send = {"name": name, "key": key, "status": 'offline'}
if master == False:
masters = channel.masters()
for master in masters:
m = Session().get(master)
if m is not None:
Log().add("[+] Client (room.py) : envoie du status de " + name + " vers l'utilisateur : " + m.getName())
json = Protocol.forgeJSON('status', simplejson.JSONEncoder().encode(to_send), {'channel': channel.name})
m.addResponse(json)
else:
users = channel.users()
for user in users:
u = Session().get(user)
if u is not None:
Log().add("[+] Client (room.py) : envoie du status master vers l'utilisateur : " + u.getName())
json = Protocol.forgeJSON('status', simplejson.JSONEncoder().encode(to_send), {'channel': channel.name})
u.addResponse(json)
def forward(self, channelName, appName, commande, uid, app):
"""Return : Envoie une commande a tous les utilisateurs d'une application -> bool """
from commons.session import Session
from log.logger import Log
if self.chanExists(channelName=channelName, appName=appName):
channel = self.Channel(channelName=channelName, appName=appName)
if uid in channel.masters():
users = channel.users()
master = Session().get(uid)
json = Protocol.forgeJSON('forward', '["' + master.getName() + '", "' + commande + '"]',
{'channel': channelName, 'app': appName})
if self.filter.RunIn(json) == True:
channel.history.add(uid, json)
for u in users:
user = Session().get(u)
if user is not None:
user.addResponse(json)
if len(users) > 0:
return True
return False
def __cmd_list(self, args):
"""
Retourne la liste d'utilisateurs d'un channel
"""
from commons.session import Session
str = []
channelName = args['channel']
appName = args['app']
if args['channel'] is None:
users = self.client.room.list_users(channelName=args, appName=appName)
else:
users = self.client.room.list_users(channelName=channelName, appName=appName)
ruid = args.get('uid')
channel = self.client.room.Channel(channelName=channelName, appName=appName)
isMaster = False
if channel:
isMaster = channel.isMaster( ruid )
for u in users:
user = Session().get(u)
if user is not None:
# if sender isclient and user is client: continue
key = user.unique_key
isMaster2 = False
if channel:
isMaster2 = channel.isMaster( key )
if not isMaster and not isMaster2:
continue
status = user.status
name = user.getName()
to_send = {"name": name, "key": key, "status": status}
str.append(to_send)
return (simplejson.JSONEncoder().encode(str))
def status(self, client, appName, master=False):
"""
Envoie le status aux clients lors d'une action ( join / part ... connect ...)
"""
from commons.session import Session
if client.room_name:
channel = client.room.Channel(channelName=client.room_name,
appName=appName)
if channel and client.unique_key in channel.masters():
master = True
if channel and master == False:
masters = channel.masters()
for master in masters:
if client.room_name:
channel = client.room_name
else:
channel = "none"
master = Session().get(master)
if master is not None:
status = client.status
key = client.unique_key
name = client.getName()
to_send = {"name": name, "key": key, "status": status}
Log().add("[+] Client: envoie du status de %s vers l'utilisateur: %s" %
(name, master.getName()), 'yellow')
json = Protocol.forgeJSON('status', simplejson.JSONEncoder().encode(to_send), {'channel': channel})
master.addResponse(json)
elif channel is not None:
for u in channel.users():
user = Session().get(u)
if user is not None:
status = client.status
key = client.unique_key
name = client.getName()
to_send = {"name": name, "key": key, "status": status}
Log().add("[+] Client: envoie du status master vers l'utilisateur: %s" % name, 'yellow')
json = Protocol.forgeJSON('status', simplejson.JSONEncoder().encode(to_send), {'channel': client.room_name})
if user is not None:
user.addResponse(json)
