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
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?')