def GETCHNL(self, params):
chid = params['chid']
chnl = self.channels.get(Query()['chid'] == chid)
if chnl is None:
return db_proto.Response(code=DBRespCode.FAIL,
data={'msg': 'Channel not found'})
return db_proto.Response(code=DBRespCode.OK, data=chnl)
def CHECKPWD(self, params):
name = params['name'][-1]
pwd = params['passwd'][-1]
user = self.users.get(Query()['name'] == name)
if pwd == user['passwd']:
return db_proto.Response(code=DBRespCode.OK)
return db_proto.Response(code=DBRespCode.FAIL)
def USRVERIFIED(self, params):
usr = self.users.get(Query()['uid'] == params['uid'])
if usr is None:
return db_proto.Response(code=DBRespCode.FAIL)
self.users.update({'verified': True}, doc_ids=[usr.doc_id])
self.users.update(delete('verify_token'), doc_ids=[usr.doc_id])
return db_proto.Response(code=DBRespCode.OK)
def CREATECHNL(self, params):
target, initiator = params['target'], params['initiator']
if target == initiator:
return db_proto.Response(code=DBRespCode.FAIL,
data={'msg': 'Users must be different'})
users = []
for uid in target, initiator:
usr = self.users.get(Query()['uid'] == uid)
if usr is None:
return db_proto.Response(code=DBRespCode.FAIL,
data={'msg': 'User not found'})
users.append(usr)
chid = create_unique_token(
[chnl['chid'] for chnl in self.channels.all()])
self.channels.insert({
'chid': chid,
'status': params['status'],
'target': users[0],
'initiator': users[1],
'buffer': {
params['target']: [],
params['initiator']: []
}
})
return db_proto.Response(code=DBRespCode.OK, data={'chid': chid})
def DELALLUSR(self, params):
raise Exception('DELALLUSR tried')
try:
self.users.purge()
return db_proto.Response(code=DBRespCode.OK)
except Exception:
return db_proto.Response(code=DBRespCode.FAIL)
def CHECKPWD(self, params):
# Checks if provided password is correct
# Requires: `uid`, `passwd`
#
record = self.private.get(Query()['uid'] == params['uid'])
if params['passwd'] == record['passwd']:
return db_proto.Response(code=DBRespCode.OK)
return db_proto.Response(code=DBRespCode.FAIL)
def GETSESS(self, params):
# Returns session with provided ssid
# Requires: `ssid`
#
sess = self.sessions.get(Query()['ssid'] == params['ssid'])
if sess is None:
return db_proto.Response(code=DBRespCode.FAIL)
return db_proto.Response(code=DBRespCode.OK, data=sess)
def CHECKSSID(self, params):
client_ip = params['client_ip'][-1]
ssid = params['ssid'][-1]
user = self.users.get(Query()['SSID'] == ssid)
if user and user['client_ip'] == client_ip and \
(int(time.time()) - user['lastAct'] < self.EXPIRE_TIME):
return db_proto.Response(code=DBRespCode.OK, data=[user['name']])
return db_proto.Response(code=DBRespCode.FAIL)
def CHANGECHNLSTATUS(self, params):
chid = params['chid']
new_status = params['status']
if self.channels.get(Query()['chid'] == chid) is None:
return db_proto.Response(code=DBRespCode.FAIL,
data={'msg': 'Channel not found'})
self.channels.update({'status': new_status}, Query()['chid'] == chid)
return db_proto.Response(code=DBRespCode.OK)
def GETUSRBYID(self, params):
# Returns user info for given uid
# Requires: `uid`
#
user = self.users.get(Query()['uid'] == params['uid'])
if user is None:
return db_proto.Response(code=DBRespCode.FAIL)
return db_proto.Response(code=DBRespCode.OK, data=user)
def UPDSESS(self, params):
# Updates lastUpd timestamp
# Requires: `ssid`
#
sess = self.sessions.get(Query()['ssid'] == params['ssid'])
if sess is None:
return db_proto.Response(code=DBRespCode.FAIL)
self.sessions.update({'lastUpd': int(time.time())},
doc_ids=[sess.doc_id])
return db_proto.Response(code=DBRespCode.OK)
def GETIDBYNAME(self, params):
# Checks if user with provided name exists
# Return uid if user found
# Requires: `name`
#
user = self.users.get(Query()['name'] == params['name'])
if user is not None:
return db_proto.Response(code=DBRespCode.OK,
data={'uid': user['uid']})
return db_proto.Response(code=DBRespCode.FAIL)
def DELUSR(self, params):
# Delets user, if passwd provided correctly
# Requires: `uid`, `passwd`
#
record = self.private.get(Query()['uid'] == params['uid'])
if params['passwd'] == record['passwd']:
self.private.remove(doc_ids=[record.doc_id])
self.users.remove(Query()['uid'] == [params['uid']])
return db_proto.Response(code=DBRespCode.OK)
return db_proto.Response(code=DBRespCode.FAIL)
def perform(self, request):
perform = getattr(self, request.method, None)
if not perform:
return db_proto.Response(code=DBRespCode.FAIL,
data={'msg': 'Unsupported method'})
try:
return perform(request.params)
except Exception as err:
traceback.print_exc()
self.__log_err(err)
return db_proto.Response(code=DBRespCode.FAIL)
def NEWUSR(self, params):
name = params['name'][-1]
passwd = params['passwd'][-1]
if self.users.contains(Query()['name'] == name):
return db_proto.Response(code=DBRespCode.FAIL)
self.users.insert({
'name': name,
'passwd': passwd,
'registerDate': time.ctime(),
'logged': False
})
return db_proto.Response(code=DBRespCode.OK)
def USROFF(self, params):
ssid = params['ssid'][-1]
self.users.update({'logged': False}, Query()['SSID'] == ssid)
self.users.update(delete('lastAct'), Query()['SSID'] == ssid)
self.users.update(delete('client_ip'), Query()['SSID'] == ssid)
self.users.update(delete('SSID'), Query()['SSID'] == ssid)
return db_proto.Response(code=DBRespCode.OK)
def perform(self, request):
perform = getattr(self, request.method, None)
if not perform:
raise Exception('Unsupported request method')
try:
return perform(request.params)
except Exception as err:
self.__log_err(err)
return db_proto.Response(code=DBRespCode.FAIL)
def DROPSESS(self, params):
# Removes session with given ssid
# Requires: `ssid`
#
ssid = params['ssid']
sess = self.sessions.get(Query()['ssid'] == ssid)
if sess is not None:
self.sessions.remove(doc_ids=[sess.doc_id])
return db_proto.Response(code=DBRespCode.OK)
def FINDCHNLBYTGT(self, params):
uid = params['uid']
status = params.get('status')
if status is not None:
chnls = self.channels.search((Query()['target']['uid'] == uid)
& (Query()['status'] == status))
else:
chnls = self.channels.search(Query()['target']['uid'] == uid)
return db_proto.Response(code=DBRespCode.OK, data=chnls)
def GETNAMESBYIDS(self, params):
# Return user names for given uids
# Requires: `uids`
#
names = []
for uid in params['uids']:
usr = self.users.get(Query()['uid'] == uid)
if usr is not None:
names.append((uid, usr['name']))
return db_proto.Response(code=DBRespCode.OK, data=names)
def USRON(self, params):
name = params['name'][-1]
client_ip = params['client_ip'][-1]
ssid = uuid.uuid4().hex
self.users.update(
{
'logged': True,
'client_ip': client_ip,
'SSID': ssid,
'lastAct': int(time.time())
},
Query()['name'] == name)
return db_proto.Response(code=DBRespCode.OK, data=[ssid])
def CREATEUSR(self, params):
# Create new user if possible
# Returns uid of created user
# Requires: `name`, `passwd`, `email`
#
if self.users.contains(Query()['name'] == params['name']):
return db_proto.Response(
code=DBRespCode.FAIL) # Name must be unique
token = create_unique_token([])
doc_id = self.users.insert({
'name': params['name'],
'email': params['email'],
'verified': False,
'verify_token': token,
'registerDate': time.ctime()
})
uid = SEED + doc_id
self.users.update({'uid': uid}, doc_ids=[doc_id])
self.private.insert({'uid': uid, 'passwd': params['passwd']})
return db_proto.Response(code=DBRespCode.OK,
data={
'uid': uid,
'verify_token': token
})
def send(self, method, params={}):
# Forms request from given method and params
# Sends it to DBServer
# Waits for response and returns it
#
response = None
ipc = socket.socket(socket.AF_UNIX)
ipc.settimeout(self.sock_timeout)
try:
request = db_proto.Request(method=method, params=params).bytes
ipc.connect(self.ipc_path)
ipc.sendall(request)
response = self.recvall(ipc)
except Exception as e:
self._log_err(e)
finally:
ipc.close()
if response is not None:
return db_proto.Response(response)
def CREATESESS(self, params):
# Creates session for user
# Returns generated ssid
# Requires: `uid`
#
for i in range(0, 10):
ssid = uuid.uuid4().hex
SSIDs = [sess['ssid'] for sess in self.sessions.all()]
if ssid not in SSIDs:
break
else:
raise Exception('Number of attempts exceeded')
self.sessions.upsert(
{
'uid': params['uid'],
'ssid': ssid,
'lastUpd': int(time.time())
},
Query()['uid'] == params['uid'])
return db_proto.Response(code=DBRespCode.OK, data={'ssid': ssid})
def send(self, request):
query = request.bytes
ipc = socket.socket(socket.AF_UNIX)
ipc.settimeout(self.sock_timeout)
try:
ipc.connect(self.ipc_path)
except socket.timeout:
raise ClientError('DB is not answering')
try:
ipc.sendall(query)
except InterruptedError:
try:
ipc.sendall(query)
except InterruptedError:
raise ClientError('Sending query malformed')
response = self._recv(ipc)
ipc.close()
return db_proto.Response(response)
def LISTUSR(self, params):
data = []
for user in self.users:
data.append(user['name'])
return db_proto.Response(code=DBRespCode.OK, data=data)
def CHECKUSR(self, params):
name = params['name'][-1]
if self.users.contains(Query()['name'] == name):
return db_proto.Response(code=DBRespCode.OK)
return db_proto.Response(code=DBRespCode.FAIL)
def DROPCHNL(self, params):
chid = params['chid']
chnl = self.channels.get(Query()['chid'] == chid)
if chnl is not None:
self.channels.remove(doc_ids=[chnl.doc_id])
return db_proto.Response(code=DBRespCode.OK)
def ONLINEUIDS(self, params):
# Returns list of uids of logged users
# Requires: -
#
uids = [sess['uid'] for sess in self.sessions.all()]
return db_proto.Response(code=DBRespCode.OK, data={'uids': uids})
