def run(self):
# TODO: Make MessageReceiver receive and handle payloads
parser = MessageParser()
while True:
package = self.connection.recv(4096)
if package:
parser.parse(package)
def run(self):
# TODO: Make MessageReceiver receive and handle payloads
parser = MessageParser()
while True:
package = self.connection.recv(4096)
if package:
parser.parse(package)
def handle(self):
"""
This method handles the connection between a client and the server.
"""
self.ip = self.client_address[0]
self.port = self.client_address[1]
self.connection = self.request
# Init
self.messageEncoder = MessageEncoder()
self.messageParser = MessageParser()
# Loop that listens for messages from the client
while True:
received_string = self.connection.recv(4096).decode()
if received_string == "":
self.connection.close()
del connected_clients[self.connection]
break
else:
payload = self.messageParser.parse(received_string)
if 'login' in payload.keys():
if re.match("^[A-Za-z0-9_-]*$", payload['login']):
self.connection.send(
self.messageEncoder.encode_history(
history).encode())
connected_clients[self.connection] = payload['login']
else:
self.connection.send(
self.messageEncoder.encode_error(
"Invalid username").encode())
elif 'logout' in payload.keys():
self.connection.close()
del connected_clients[self.connection]
return
elif 'message' in payload.keys():
message = self.messageEncoder.encode_message(
connected_clients[self.connection], payload['message'])
history.append(message)
for conn in connected_clients.keys():
conn.send(message.encode())
elif 'names' in payload.keys():
self.connection.send(
self.messageEncoder.encode_info(', '.join(
connected_clients.values())).encode())
elif 'help' in payload.keys():
self.connection.send(
self.messageEncoder.encode_info(
"This is the help").encode())
def jsonReceived(self, jsonObj):
self.logMsg("odebralem obiekt json")
msgType = jsonObj['TYPE']
if msgType == "HII" and ( self.state == WAIT_FOR_HII_OR_P2P or self.state == WAIT_FOR_HII):
appVar.coreInstance.handleHiiMessage(jsonObj, self)
self.state = WAIT_FOR_MTX
elif msgType == "P2P" and self.state == WAIT_FOR_HII_OR_P2P:
# otrzymalismy P2P wiec przedstawiamy sie i oczekujemy na LOG
msgToSend = MessageParser.getFullHiiMsg()
self.logMsg("wysyłam wiadomosc i czekam na log msg : '%s'" % msgToSend)
self.sendPacket(msgToSend)
self.state = WAIT_FOR_LOG
elif msgType == "LOG" :#TODO: mozliwy forward wiadomosci!!!
if appVar.coreInstance.handleLogMessage(jsonObj, self):
self.state = CONNECTED
else:
self.logMsg("odrzucono logowanie - przerywam polaczenie")
self.transport.loseConnection()
elif msgType == 'MTX':
appVar.coreInstance.handleMtxMessage(jsonObj)
self.state = CONNECTED
elif msgType == 'MSG':
appVar.coreInstance.handleMsgMessage(jsonObj)
elif msgType == 'OUT':
appVar.coreInstance.handleOutMessage(jsonObj)
elif msgType == 'LIV':
appVar.coreInstance.handleLivMessage(jsonObj)
else:
self.logMsg("bledny typ wiadomosci '%s' w stanie %d" % (msgType, self.state))
self.state = DISCONNECTED
self.transport.loseConnection()
def sendPacket(self, msg):
if msg.__class__ == {}.__class__:
jsonTxt = json.dumps(msg)
msg = MessageParser.getMsgWithJSONInside(jsonTxt)
if self.delay > 0:
self.__reactor.callLater(self.delay, self.__doSendPacket, msg)
else:
self.__doSendPacket(msg)
class ClientHandler(socketserver.BaseRequestHandler):
"""
This is the ClientHandler class. Everytime a new client connects to the
server, a new ClientHandler object will be created. This class represents
only connected clients, and not the server itself. If you want to write
logic for the server, you must write it outside this class
"""
def handle(self):
"""
This method handles the connection between a client and the server.
"""
self.ip = self.client_address[0]
self.port = self.client_address[1]
self.connection = self.request
# Init
self.messageEncoder = MessageEncoder()
self.messageParser = MessageParser()
# Loop that listens for messages from the client
while True:
received_string = self.connection.recv(4096).decode()
if received_string == "":
self.connection.close()
del connected_clients[self.connection]
break
else:
payload = self.messageParser.parse(received_string)
if 'login' in payload.keys():
if re.match("^[A-Za-z0-9_-]*$", payload['login']):
self.connection.send(
self.messageEncoder.encode_history(
history).encode())
connected_clients[self.connection] = payload['login']
else:
self.connection.send(
self.messageEncoder.encode_error(
"Invalid username").encode())
elif 'logout' in payload.keys():
self.connection.close()
del connected_clients[self.connection]
return
elif 'message' in payload.keys():
message = self.messageEncoder.encode_message(
connected_clients[self.connection], payload['message'])
history.append(message)
for conn in connected_clients.keys():
conn.send(message.encode())
elif 'names' in payload.keys():
self.connection.send(
self.messageEncoder.encode_info(', '.join(
connected_clients.values())).encode())
elif 'help' in payload.keys():
self.connection.send(
self.messageEncoder.encode_info(
"This is the help").encode())
def WriteEveryClassInDotCppFile(allMessageName, dotCppPointer):
all_class_header = GetEveryClassHeader(allMessageName)
all_class_ctor = GetEveryClassCtor(allMessageName)
all_class_dtor = GetEveryClassDtor(allMessageName)
for i in range(len(allMessageName)):
#WriteInDotCppFile(all_class_header[i] + NextLine() + PublicDeclaration() + \
# all_class_ctor[i] + NextLine() + all_class_dtor[i] + PublicDeclaration(), dotCppPointer)
every_class_member_function_name = MessageParser.GetEveryClassMemberFunction(
i, "dotCpp", allMessageName[i])
WriteMemberFunctionInDotCppFile(every_class_member_function_name,
dotCppPointer)
def handle(raw_msg):
msg = MessageParser.Message(raw_msg)
persondb.addPerson(msg.mfrom) # logs every person!
if msg.chat.type == "private":
log.debug("private message received")
#chatsdb.addChat(msg.chat)
chatid = msg.chat.id
# add the user
usersdb.addUser(msg.mfrom, chatid)
user = usersdb.getUser(msg.mfrom)
# received a message user is supposedly active
user.isActive = True
if user.accepted_terms == False:
log.debug("handle privacy policy")
Handle.handle_privacy_policy(bot, usersdb, user, msg.content)
else:
# flag to send main menu
send_main_menu = True
# check the content if there is piped some request
send_main_menu = Handle.handle_content(msg.content, bot, user,
categoriesdb, mediavotedb)
# analyize content
if msg.content.type == "text" and send_main_menu:
# log the messages to the bot
text = msg.content.text
log_msg = text if len(text) < 244 else text[:241] + "..."
log_msg = log_msg.encode("utf-8").decode(
"ascii", "backslashreplace")
log.debug("Message: " + log_msg)
# handle the requests
send_main_menu = Handle.handle_private_text(
msg.content.text, bot, user, usersdb, categoriesdb,
mediavotedb)
if send_main_menu:
Handle.send_main_menu(bot, user)
#chatsdb.update()
usersdb.update()
categoriesdb.update()
mediavotedb.update()
persondb.update()
def update(self):
#check for messages from server
try:
data = self.sock.recv(512) #TODO: change to server's max possible message length
if data:
while not data.endswith(';'):
data += self.sock.recv(1)
messages = [m for m in data.split(';') if m != '']
for m in messages:
MessageParser.parse(m)
#print 'Message from server: ' + m #TODO: delete this when all parsing functions are implemented
else:
Shared.main_window.calls.put((Shared.main_window.destroy,))
print 'Server Disconnected'
except socket.error:
#since the socket is non-blocking, it will raise an error each time it doesn't receive any data
pass
#check outgoing messages queue
while not self.outgoing_messages.empty():
msg = self.outgoing_messages.get()
self.sock.send(msg)
print 'Sent message to server: ' + msg
def connectionMade(self):
self.logMsg("nowe polaczenie")
self.transport.setTcpNoDelay(True)
if self.state == INIT:
appVar.tcpManager.newConnection(self)
if self.isClient and self.isReversed == False:
# to my utworzylismy polaczenie wiec wysylamy hii msg i czekamy na log
self.state = WAIT_FOR_LOG
msgToSend = MessageParser.getFullHiiMsg()
self.logMsg("wysyłam wiadomosc i czekam na log msg : '%s'" % msgToSend)
self.sendPacket(msgToSend)
elif self.isClient and self.isReversed:
# to my utworzylismy polaczenie wiec wysylamy P2P i czekamy na HII msg
self.logMsg("czekam na znacznik %s")
self.sendPacket(MessageParser.getFullP2pMsg())
self.state = WAIT_FOR_HII
else:
# ktos do nas sie podlaczyl wiec poprostu czekamy na HII lub P2P
self.logMsg("czekam na hii/multitalk message")
self.state = WAIT_FOR_HII_OR_P2P
else:
self.logMsg("bledny stan protokolu")
assert(False)
def lineReceived(self, line):
#self.logMsg("otrzymałem linie tekstu")
if self.state == WAIT_FOR_HII_OR_P2P and line == MULTITALK_TAG:
#ktos podlaczyl sie do nas podajac z palca IP wiec wysylamy mu HII i oczekujemy na LOG
msgToSend = MessageParser.getFullHiiMsg()
self.logMsg("wysylam hi msg '%s'" % msgToSend)
self.sendPacket(msgToSend)
self.state = WAIT_FOR_LOG
return
elif self.state == WAIT_FOR_HII_OR_P2P:
self.logMsg("niedopasowalem znacznika %s wiec oczekuja ze otrzymam HII" % MULTITALK_TAG)
len = MessageParser.getMessageLen(line)
if len:
#self.logMsg("otrzymalem naglowek - czekam na odczyt %d bajtow" % len)
self.packetSize = len
self.toRead = len
#teraz chcemy odczytać wnętrze pakietu
self.packet = ""
self.setRawMode()
else:
#self.logMsg("przerywam polaczenie - bledy poczatek pakietu: '%s'" % line)
#self.transport.loseConnection()
self.logMsg("bledy poczatek pakietu - ignoruje go: '%s'" % line)
def server_thread():
global users_sockets, should_exit
while not should_exit:
for username in users_sockets.keys():
#check the active socket for data
try:
data = users_sockets[username].main_socket.recv(512)
if data:
while not data.endswith(';'):
data += users_sockets[username].main_socket.recv(1)
messages = [m for m in data.split(';') if m != '']
for msg in messages:
print 'got message from user '+ username+ ' : '+ msg
MessageParser.parse(msg, username)
else:
print username + "'s main socket disconnected"
MessageParser.parse_user_state_changed(0, username)
users_sockets[username].close()
users_sockets.pop(username, None)
continue
except socket.error: pass
#check all the sleeping sockets for disconnection
if any(users_sockets[username].sleeping_sockets):
ready_to_read, wr, er = select.select(users_sockets[username].sleeping_sockets, [], [], 0)
for sock in ready_to_read:
try:
if not sock.recv(2):
print 'a sleeping socket from ' + username + ' had disconnected'
sock.close()
users_sockets[username].remove(sock)
except socket.error: pass
time.sleep(1.0/60.0)
print 'server thread ended'
class MessageReceiver(object):
def __init__(self, sock):
self.sock = sock
self.parser = MessageParser()
def receive(self):
try:
data = self.sock.recv(2048)
#TODO make sure completely received data from client
if data:
message = self.parser.parse(data)
return message
return None
except:
traceback.print_exc()
return None
class MessageReceiver(object):
def __init__(self, sock):
self.sock = sock
self.parser = MessageParser()
def receive(self):
try:
data = self.sock.recv(2048)
#TODO make sure completely received data from client
if data:
message = self.parser.parse(data)
return message
return None
except:
traceback.print_exc()
return None
def main():
try:
print("Starting the SenseHat module...")
global DISPLAY_MANAGER
global MESSAGE_PARSER
DISPLAY_MANAGER = DisplayManager()
MESSAGE_PARSER = MessageParser()
hubManager = HubManager()
while True:
time.sleep(1000)
except IoTHubError as iothub_error:
print("Unexpected error %s from IoTHub" % iothub_error)
return
except KeyboardInterrupt:
print("IoTHubClient sample stopped")
def generate(requirements, fix_spec):
requiredFieldsComponents = RequiredFieldsComponents.RequiredFieldsComponents(
requirements)
fix_specs = xml_parser.parse(fix_spec)
component_parser = ComponentParser.ComponentParser(
requiredFieldsComponents)
message_parser = MessageParser.MessageParser(requiredFieldsComponents,
component_parser)
header_list_comp = []
header_messages = dict()
required_header_fields = []
print("----- Processing Required Fields for QuickFIX Components -----")
component_parser.parse_components(fix_specs)
print("--------------------------------------------------------------\n")
print("----- Processing Required Fields for QuickFIX Header -----")
header_out = component_parser.parse_components_rec(
'Header', fix_specs.find('header'), header_messages, header_list_comp,
required_header_fields, False)
component_dependency_dictionary = component_parser.component_dep_dict
# this list is required to populate dependecies for MPC to work
print("--------------------------------------------------------------\n")
print("----- Processing Required Fields for QuickFIX Message -----")
message_parser.parse_messages(fix_specs, component_dependency_dictionary)
print("--------------------------------------------------------------\n")
component_parser.compenent_dict["Header"] = header_out
component_parser.complete_dependency_list.append("Header")
component_parser.component_dep_dict["Header"] = []
message_parser.store_message()
component_parser.store_components()
def formResponse(sender_id, text):
msg_type = MessageParser.parse(text)
responseList = []
if msg_type == MessageParser.GREETING_MSG:
message1 = '''Hello, Welcome to IPO Notifier.'''
message2 = '''You can use following Keywords to get IPO details.
- Upcoming IPO
- Today's IPO, Current IPO
- Recent IPO
- Help.'''
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
jsonFormat = generateJSONResposneForText(message2)
responseList.append(jsonFormat)
if not DBHelper.isSubscribed(sender_id):
jsonFormat = generateJSONResposneForPostbackButtons(
'''Do you want to Get Notified when new IPO is going to be listed on BSE or NSE?''',
'Yes, Subscribe Me', 'Subscribe', "No, Don't Notify Me",
'Unsubscribe')
responseList.append(jsonFormat)
elif msg_type == MessageParser.UNKNOWN_MSG:
message1 = "I didn't understand that. Try typing Help :P ."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
elif msg_type == MessageParser.HELP:
message1 = '''Use Following Keywords for your task.
- Upcoming IPO
- Current IPO
- Recent IPO
- ipo 'Company name'.'''
message2 = "To get latest IPO update notifications type 'Subscribe'."
if DBHelper.isSubscribed(sender_id):
message2 = "To unsubscribe from getting IPO update notifications type 'Unsubscribe'."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
jsonFormat = generateJSONResposneForText(message2)
responseList.append(jsonFormat)
elif msg_type == MessageParser.UPCOMING_IPO:
ipolist = IPOHelper.getUpcomingIPO()
for ipoData in ipolist:
jsonFormat = generateJSONResposneForIPO(ipoData)
responseList.append(jsonFormat)
elif msg_type == MessageParser.ALL_IPO:
ipolist = IPOHelper.getLast6IPO()
for ipoData in ipolist:
jsonFormat = generateJSONResposneForIPO(ipoData)
responseList.append(jsonFormat)
elif msg_type == MessageParser.IPO_NAME:
ipoName = MessageParser.parseIPOName(text)
ipolist = IPOHelper.getIPObyName(ipoName)
if not ipoName:
ipolist = IPOHelper.getRunningIPO(False)
msg1 = "Try ipo 'company name'."
msg2 = "By the way here is the running IPO List"
jsonFormat = generateJSONResposneForText(msg1)
responseList.append(jsonFormat)
if ipolist:
jsonFormat = generateJSONResposneForText(msg2)
responseList.append(jsonFormat)
for ipoData in ipolist:
jsonFormat = generateJSONResposneForIPO(ipoData)
responseList.append(jsonFormat)
#gives list of running ipo
elif msg_type == MessageParser.TODAYS_IPO:
ipolist = IPOHelper.getRunningIPO(False)
for ipoData in ipolist:
jsonFormat = generateJSONResposneForIPO(ipoData)
responseList.append(jsonFormat)
elif msg_type == MessageParser.UNSUBSCRIBE:
DBHelper.updateuser(sender_id, '0')
message1 = "We're sad to see you go. You can type 'Subscribe' any time if you want to get updates again."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
elif msg_type == MessageParser.SUBSCRIBE:
DBHelper.updateuser(sender_id, '1')
message1 = "You are successfully subscribed. We will notify you for latest IPO news and updates."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
elif msg_type == MessageParser.THANKS:
DBHelper.updateuser(sender_id, '1')
message1 = "Always happy to serve."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
if not responseList:
message1 = "Sorry, No Results Found."
jsonFormat = generateJSONResposneForText(message1)
responseList.append(jsonFormat)
return responseList
print '\nextarnal ip: ' + external_ip
#TODO: maybe use separate socket for user creation
main_socket = socket.socket()
main_socket.bind(('', 4590))
my_ip, my_port = main_socket.getsockname()
print 'internal endpoint: ' + my_ip + ':' + str(my_port)
print '\n\n------------\n'
main_socket.listen(5)
connections = [main_socket]
users_sockets = {} # { 'username': [active socket, sleeping socket1, ..., sleeping socketN] }
should_exit = False
db = Database.Database()
MessageParser.init(db, users_sockets)
t = threading.Thread(target=server_thread)
t.start()
new_connections_listener()
print 'unloading resources...'
t.join()
for con in connections:
con.close()
for socks in users_sockets.values():
socks.close()
main_socket.close()
db.close()
def sendLogMsg(self):
msgToSend = MessageParser.getFullLogMsg()
self.logMsg("wysylam log msg '%s'" % msgToSend)
self.sendPacket(msgToSend)
import os
import io
import MessageParser
from MessageParser import MessageParser
# Imports for the REST API
from flask import Flask, request
# Imports for image procesing
from PIL import Image
# Imports for prediction
from predict import initialize, predict_image, predict_url
THRESHOLD = float(os.getenv('THRESHOLD', 0))
MESSAGE_PARSER = MessageParser()
file = open('/tmp/predictions/p.txt', 'w')
app = Flask(__name__)
# 4MB Max image size limit
app.config['MAX_CONTENT_LENGTH'] = 4 * 1024 * 1024
# Default route just shows simple text
@app.route('/')
def index():
return 'CustomVision.ai model host harness'
# Like the CustomVision.ai Prediction service /image route handles either
# - octet-stream image file
# - a multipart/form-data with files in the imageData parameter
def sendOutMsgAndCloseConnection(self):
msgToSend = MessageParser.getFullOutMsg()
self.logMsg("wysylam out msg do %s" % self.transport.getPeer().host)
self.sendPacket(msgToSend)
self.transport.loseConnection()
def sendMtxMsg(self):
msgToSend = MessageParser.getFullMtxMsg()
self.sendPacket(msgToSend)
def __init__(self, sock):
self.sock = sock
self.parser = MessageParser()
def read_messages(messages):
parsed_message = mp.get_parsed_message(message)
def query(raw_msg):
query = MessageParser.CbkQuery(raw_msg, False)
query.initOptionals()
# warning user might not be in the database
user = usersdb.getUser(query.person)
log.debug(query.data)
if query.data.startswith("rmacc"):
scmd = query.data.split("_")
ans = scmd[1]
if ans == "yes":
categoriesdb.deleteCategoryUser(user, mediavotedb)
log.info("deleted categories")
mediavotedb.deleteUserMedia(user)
log.info("deleted media")
usersdb.deleteUser(user)
log.info("deleted user")
BotWrappers.sendMessage(bot, user, "All data removed")
bot.answerCallbackQuery(query.id, text='Removed')
else:
Handle.send_main_menu(bot, user)
bot.answerCallbackQuery(query.id, text='Not removed')
usersdb.update()
elif query.data.startswith("remcat_"):
st = query.data.split("_")
if len(st) == 2:
categoriesdb.deleteCategory(st[1])
bot.answerCallbackQuery(query.id, text='Deleted {}'.format(st[1]))
else:
bot.answerCallbackQuery(query.id,
text='Delete cat somethings fucky')
elif query.data.startswith("bancat_"):
st = query.data.split("_")
if len(st) == 2:
categoriesdb.banCategory(st[1])
bot.answerCallbackQuery(query.id, text='Banned {}'.format(st[1]))
else:
bot.answerCallbackQuery(query.id, text='Ban cat somethings fucky')
elif query.data.startswith("cp_"):
# change page
cmd_list = query.data.split("_")
if len(cmd_list) < 4:
raise Exception("list too short")
page_n = int(cmd_list[2])
prev = True if cmd_list[3] == "prev" else False
if cmd_list[1] == "cat":
Handle.answer_categories_page(bot, user, categoriesdb, query, prev,
page_n, mediavotedb)
elif cmd_list[1] == "shortcat":
Handle.answer_short_categories(bot, user, categoriesdb, query,
prev, page_n)
elif cmd_list[1] == "catlist":
cat_list = categoriesdb.getValues()
p = Pages.CategoryList(page_n, cat_list, query)
p.check_answer(bot, user, prev)
elif cmd_list[1] == "utop":
ulist = Handle.getSortedUserList(usersdb)
p = Pages.UserTopPages(page_n, ulist, query)
p.check_answer(bot, user, prev)
elif query.data.startswith("vote"):
# increase the upvote count or downvote count
cmd_list = query.data.split("_")
upvote = True if cmd_list[1] == "up" else False
dmedia = mediavotedb.database[int(cmd_list[2])]
media = dmedia.getData()
if user.hash_id in media.voters_id:
bot.answerCallbackQuery(query.id, text='Already voted')
else:
if upvote:
media.upvotes += 1
else:
media.downvotes += 1
# add to the media the voters
media.voters_id.append(user.hash_id)
mediavotedb.setMedia(media)
# give / subtract a point from the media owner
media_user = usersdb.hGetUser(media.creator_hash_id)
coin = str(NumberFormatter.PellaCoins(1))
if upvote:
media_user.pella_coins += 1
BotWrappers.sendMessage(
bot, media_user,
"Somebody upvoted your media. You received " + coin)
else:
media_user.pella_coins -= 1
BotWrappers.sendMessage(
bot, media_user,
"Somebody downvoted your media. You lost " + coin)
usersdb.setUser(media_user)
# give a point to the voter
user.pella_coins += 1
BotWrappers.sendMessage(bot, user,
"You voted a media. You received " + coin)
usersdb.setUser(user)
mediavotedb.update()
usersdb.update()
bot.answerCallbackQuery(query.id, text='Voted!')
elif query.data.startswith("hide"):
# hide the picture
scmd = query.data.split("_")
uid = scmd[1]
if uid not in user.no_show_ids:
user.no_show_ids.append(uid)
bot.answerCallbackQuery(query.id, text='Hidden')
elif query.data.startswith("report"):
# send report to the admins
# send the creator a message with the option to ban/delete media
# send the category creator a message with the option to delete the
# media
pass
elif query.data.startswith("delete"):
# delete picture if enough money
pass
else:
bot.answerCallbackQuery(query.id, text='what?')
def __init__(self, sock):
self.sock = sock
self.parser = MessageParser()
