def run(self):
        """
        The main loop of the program.

        Code design suggestions:
            1. Parse server in_buf of the stream.
            2. Handle all packets were received from our Stream server.
            3. Parse user_interface_buffer to make message packets.
            4. Send packets stored in nodes buffer of our Stream object.
            5. ** sleep the current thread for 2 seconds **

        Warnings:
            1. At first check reunion daemon condition; Maybe we have a problem in this time
               and so we should hold any actions until Reunion acceptance.
            2. In every situation checkout Advertise Response packets; even is Reunion in failure mode or not

        :return:
        """
        try:
            while True:
                in_buff = self.stream.read_in_buf()
                for message in in_buff:
                    packet = PacketFactory.parse_buffer(message)
                    self.handle_packet(packet)
                self.stream.clear_in_buff()
                self.handle_user_interface_buffer()
                self.stream.send_out_buf_messages(
                    self.reunion_mode == ReunionMode.FAILED)
                time.sleep(2)
        except KeyboardInterrupt:
            log('KeyboardInterrupt')
            try:
                sys.exit(0)
            except SystemExit:
                os._exit(0)
Example #2
0
	def _predictChord(self, history):
		""" Predicts the next chord from a history. """
		if self._structure[self._instruments.top].expected(history):
			return self._structure[self._instruments.top].expectedFuzz(history)
		
		logger.log("Failed to find prediction for history %s" % str(history))
		return random.choice(self._structure[self._instruments.top].sampleSpace)
Example #3
0
def get_argument(args, arg_name):
    try:
        return args[arg_name]
    except (KeyError, IndexError):
        logger.log("Key not found: " + str(arg_name), "Arg Fetcher",
                   logger.WARNING)
        return None
 def __handle_reunion_hello_back(self, packet: Packet):
     if packet.get_addresses()[-1] == self.address:
         # It's our hello back!
         self.last_hello_back_time = time.time()
         log('We received our HelloBack.')
     else:
         self.__pass_reunion_hello_back(packet)
    def __handle_message_packet(self, packet: Packet):
        """
        Only broadcast message to the other nodes.

        Warnings:
            1. Do not forget to ignore messages from unknown sources.
            2. Make sure that you are not sending a message to a register_connection.

        :param packet: Arrived message packet

        :type packet Packet

        :return:
        """
        log(f'New message arrived: {packet.get_body()}')
        sender_address = packet.get_source_server_address()
        updated_packet = PacketFactory.new_message_packet(
            packet.get_body(), self.address)
        if self.__check_neighbour(sender_address):  # From known source
            for neighbor_address in [
                    *self.children_addresses, self.parent_address
            ]:
                if neighbor_address is not None and neighbor_address != sender_address:
                    self.stream.add_message_to_out_buff(
                        neighbor_address, updated_packet)
 def __pass_reunion_hello_back(self, packet: Packet):
     new_addresses = packet.get_addresses()[1:]
     next_node_address = new_addresses[0]
     log(f'HelloBack packet passed down to Node({next_node_address}).')
     passed_packet = PacketFactory.new_reunion_packet(
         ReunionType.RES, self.address, new_addresses)
     self.stream.add_message_to_out_buff(next_node_address, passed_packet)
    def __init__(self, code=500, msg="", args=None, log=True, variant="error"):
        self.code = code
        self.msg = msg.replace('"', "'")
        self.args = args if args else dict()

        if log:
            logger.log(code, msg, variant)
    def handle_packet(self, packet):
        """

        This function act as a wrapper for other handle_###_packet methods to handle the packet.

        Code design suggestion:
            1. It's better to check packet validation right now; For example Validation of the packet length.

        :param packet: The arrived packet that should be handled.

        :type packet Packet

        """
        if not self.__validate_received_packet(packet):
            return
        packet_type = packet.get_type()
        log(f'Packet of type {packet_type.name} received.')
        if self.reunion_mode == ReunionMode.FAILED:
            if packet_type == PacketType.ADVERTISE:
                self.__handle_advertise_packet(packet)
            return
        if packet_type == PacketType.MESSAGE:
            self.__handle_message_packet(packet)
        elif packet_type == PacketType.ADVERTISE:
            self.__handle_advertise_packet(packet)
        elif packet_type == PacketType.JOIN:
            self.__handle_join_packet(packet)
        elif packet_type == PacketType.REGISTER:
            self.__handle_register_packet(packet)
        elif packet_type == PacketType.REUNION:
            self.__handle_reunion_packet(packet)
    def __handle_register_packet(self, packet: Packet):
        """
        For registration a new node to the network at first we should make a Node with stream.add_node for'sender' and
        save it.

        Code design suggestion:
            1.For checking whether an address is registered since now or not you can use SemiNode object except Node.

        Warnings:
            1. Don't forget to ignore Register Request packets when you are a non-root peer.

        :param packet: Arrived register packet
        :type packet Packet
        :return:
        """
        register_type = self.__identify_register_type(packet)
        if self.is_root and register_type == RegisterType.REQ:
            new_node = SemiNode(packet.get_source_server_ip(),
                                packet.get_source_server_port())
            if new_node in self.registered:
                return
            self.registered.append(new_node)
            sender_address = packet.get_source_server_address()
            self.stream.add_node(sender_address, set_register_connection=True)
            register_response_packet = PacketFactory.new_register_packet(
                RegisterType.RES, self.address)
            self.stream.add_message_to_out_buff(sender_address,
                                                register_response_packet,
                                                want_register=True)
        elif register_type == RegisterType.RES:
            log('Register request ACKed by root. You are now registered.')
 def handle_advertise_command(self) -> None:
     advertise_packet = PacketFactory.new_advertise_packet(
         AdvertiseType.REQ, self.address)
     self.stream.add_message_to_out_buff(self.root_address,
                                         advertise_packet,
                                         want_register=True)
     log(f'Advertise packet added to out buff of Node({self.root_address}).'
         )
Example #11
0
    def _predictChord(self, history):
        """ Predicts the next chord from a history. """
        if self._structure[self._instruments.top].expected(history):
            return self._structure[self._instruments.top].expectedFuzz(history)

        logger.log("Failed to find prediction for history %s" % str(history))
        return random.choice(
            self._structure[self._instruments.top].sampleSpace)
Example #12
0
def filter_chat_message(msg, client_id):

    if client_id == -1:
        if msg.startswith("/"):
            Main.Command(msg, client_id)
            return None
        return msg
    acid = ""
    displaystring = ""
    currentname = ""

    for i in _ba.get_game_roster():
        if i['client_id'] == client_id:
            acid = i['account_id']
            try:
                currentname = i['players'][0]['name_full']
            except:
                currentname = "<in-lobby>"
            displaystring = i['display_string']
    if acid:
        msg = ChatFilter.filter(msg, acid, client_id)

    if msg.startswith("/"):
        return Main.Command(msg, client_id)

    if msg.startswith(",") and settings["allowTeamChat"]:
        return Main.QuickAccess(msg, client_id)

    logger.log(acid + " | " + displaystring + "|" + currentname + "| " + msg,
               "chat")

    if acid in serverdata.clients and serverdata.clients[acid]["verified"]:

        if serverdata.muted:
            _ba.screenmessage("Server on mute",
                              transient=True,
                              clients=[client_id])
            return

        elif serverdata.clients[acid]["isMuted"]:
            _ba.screenmessage("You are on mute",
                              transient=True,
                              clients=[client_id])
            return None
        elif servercheck.get_account_age(serverdata.clients[acid]["accountAge"]
                                         ) < settings['minAgeToChatInHours']:
            _ba.screenmessage("New accounts not allowed to chat here",
                              transient=True,
                              clients=[client_id])
            return None
        else:
            return msg

    else:
        _ba.screenmessage("Fetching your account info , Wait a minute",
                          transient=True,
                          clients=[client_id])
        return None
    def start_user_interface(self) -> None:
        """
        For starting UserInterface thread.

        :return:
        """
        if not self.is_root:
            log('UserInterface started.')
            self.user_interface.start()
Example #14
0
	def _predictNote(self, realHistory, partName):
		""" Predicts the next note from a history that is being provided. """
		normalizedHistory = music42.normalizeNotes(realHistory)
		
		if self._melody[partName].expected(normalizedHistory):
			return music42.denormalizeNote(self._melody[partName].expectedFuzz(normalizedHistory), realHistory)
		
		logger.log("Failed to find prediction for history %s" % (normalizedHistory,))
		return random.choice(self._alphabets[partName])
 def __register(self) -> None:
     if self.stream.add_node(self.root_address,
                             set_register_connection=True):
         register_packet = PacketFactory.new_register_packet(
             RegisterType.REQ, self.address)
         self.stream.add_message_to_out_buff(self.root_address,
                                             register_packet,
                                             want_register=True)
         log(f'Register packet added to out buff of Node({self.root_address}).'
             )
def check_heart_beat(ws):
    should_exit = False
    while not should_exit:
        time.sleep(10)
        now = time.time()
        for _, last_tick in last_heart_beat_map.items():
            # If 10 seconds a topic missed, then should reconnect
            if now - last_tick > 10:
                log('Not got pong, exit process')
                ws.close()
                should_exit = True
Example #17
0
    def signup(self):
        u"""用户注册"""
        param = {
            "p_username": self.username,
            "p_mobile": self.mobile,
            "p_password": Encrypt().encrypt(self.password, 'SHA1')
        }

        response = self._signandpost(param, 'AddUser')
        log(response, 'Sign Up', 'info')
        return json.loads(response)['p_userid']
Example #18
0
    def signup(self):
        u"""用户注册"""
        param = {
            "p_username": self.username,
            "p_mobile": self.mobile,
            "p_password": Encrypt().encrypt(self.password, 'SHA1')
        }

        response = self._signandpost(param, 'AddUser')
        log(response, 'Sign Up', 'info')
        return json.loads(response)['p_userid']
Example #19
0
    def _predictNote(self, realHistory, partName):
        """ Predicts the next note from a history that is being provided. """
        normalizedHistory = music42.normalizeNotes(realHistory)

        if self._melody[partName].expected(normalizedHistory):
            return music42.denormalizeNote(
                self._melody[partName].expectedFuzz(normalizedHistory),
                realHistory)

        logger.log("Failed to find prediction for history %s" %
                   (normalizedHistory, ))
        return random.choice(self._alphabets[partName])
        def callback(address, queue, data):
            """
            The callback function will run when a new data received from server_buffer.

            :param address: Source address.
            :param queue: Response queue.
            :param data: The data received from the socket.
            :return:
            """
            log('New data received.')
            queue.put(bytes('ACK', 'utf8'))
            self._server_in_buf.append(data)
Example #21
0
def save_ids(ids, pb_id, display_string):

    pdata.update_display_string(pb_id, ids)

    if display_string not in ids:
        msg = "Spoofed Id detected , Goodbye"
        _ba.pushcall(Call(kick_by_pb_id, pb_id, msg), from_other_thread=True)
        serverdata.clients[pb_id]["verified"] = False
        logger.log(pb_id + "|| kicked , for using spoofed id " +
                   display_string)
    else:
        serverdata.clients[pb_id]["verified"] = True
Example #22
0
def save_age(age, pb_id, display_string):

    pdata.add_profile(pb_id, display_string, display_string, age)
    time.sleep(2)
    thread2 = FetchThread(target=get_device_accounts,
                          callback=save_ids,
                          pb_id=pb_id,
                          display_string=display_string)
    thread2.start()
    if get_account_age(age) < settings["minAgeToJoinInHours"]:
        msg = "New Accounts not allowed to play here , come back tmrw."
        logger.log(pb_id + "|| kicked > new account")
        _ba.pushcall(Call(kick_by_pb_id, pb_id, msg), from_other_thread=True)
 def __run_root_reunion_daemon(self):
     graph_nodes = self.network_graph.nodes
     for graph_node in graph_nodes:
         if graph_node.address == self.address:
             continue
         time_passed_since_last_hello = time.time() - graph_node.last_hello
         log(f'Time passed since last hello from Node({graph_node.address}): {time_passed_since_last_hello}'
             )
         if time_passed_since_last_hello > MAX_HELLO_INTERVAL:
             self.stream.remove_node(
                 self.stream.get_node_by_address(graph_node.address[0],
                                                 graph_node.address[1]))
             self.network_graph.remove_node(graph_node.address)
    def send_message(self) -> None:
        """
        Final function to send buffer to the client's socket.

        :return:
        """
        for packet in self.out_buff:
            response = self.client.send(packet.get_buf())
            if response != b'ACK':
                log(f"Node({self.get_server_address()}): Message of type {packet.get_type()} not ACKed."
                    )

        self.out_buff.clear()
 def __handle_advertise_response(self, packet: Packet) -> None:
     self.last_hello_time = time.time()
     self.last_hello_back_time = time.time()
     parent_address = packet.get_advertised_address()
     log(f'Trying to join Node({parent_address})...')
     self.parent_address = parent_address
     join_packet = PacketFactory.new_join_packet(self.address)
     self.stream.add_node(
         parent_address)  # Add a non_register Node to stream to the parent
     log(f'Join Request added to out buf on Node({parent_address}).')
     self.stream.add_message_to_out_buff(parent_address, join_packet)
     self.reunion_mode = ReunionMode.ACCEPTANCE
     if not self.reunion_daemon.is_alive():
         self.reunion_daemon.start()
Example #26
0
def dump(dataType, data, *corpusID):
	""" Dumps an analysis of a certain corpus to `dumps/<corpusID>/<dataType>.p`.
	
	>>> data = "test"
	>>> dump('melody', data, 'nonsense')
	True
	
	Test to see which music21 objects cause trouble.
	>>> from music21 import note
	>>> noteData = note.Note('A4')
	>>> dump('melody', noteData, 'weakref')
	True
	>>> restData = note.Rest('half')
	>>> dump('melody', restData, 'weakref')
	True
	
	This (Note and Rest) seems to have worked. Next.
	>>> from music21 import stream
	>>> measureData = stream.Measure()
	
	It works for empty streams.
	>>> dump('melody', measureData, 'weakref')
	True
	
	But not for streams with children.
	# >>> measureData.append(noteData)
	# >>> dump('melody', measureData, 'weakref')
	# True
	
	Boom. But we don't use streams in the Note ngrams. So what's the dealio?
	# >>> noteData.quarterLength = 3
	# >>> dump('melody', noteData, 'weakref')
	# True
	
	OK, got it. Durations seems to be saved as weakrefs, too.
	Avoided the issue by creating "normalized" note objects.
	<http://docs.python.org/library/pickle.html#pickling-and-unpickling-extension-types>
	God save the Queen, pickling is already supported in music21: <http://code.google.com/p/music21/source/browse/trunk/music21/converter.py>
	"""
	try:
		with open(_pathForDump(corpusID, dataType, True), 'w') as f:
			try:
				pickle.dump(data, f)
				return True
			except pickle.PicklingError:
				logger.log("%s can not be pickled." % (data))
				return False
	except IOError:
		logger.log("Couldn't open file for writing.")
		return False
def on_open(ws):
    log("### opened ###")

    # Ticker
    for currency in CURRENCY_LIST:
        ws.send('{"event":"subscribe", "channel":"ticker", "pair":"' +
                currency + 'USD"}')
        # ws.send('{"event":"subscribe", "channel":"trades", "pair":"' + currency + 'USD"}')
        # ws.send('{"event":"subscribe", "channel":"book", "pair":"' + currency + 'USD", "prec":"P0", "freq":"F0"}')

    # Health Beat
    global checker_process
    checker_process = Process(target=check_heart_beat, args=(ws, ))
    checker_process.start()
Example #28
0
 def __init__(self, mobile=None, username=None, password=None):
     u"""如果没有同时传入mobile,username和password,则随机生成,用户名与密码等于随机生成的手机号"""
     if mobile is None and username is None and password is None:
         r_phone = random_phone_number()
         self.mobile = self.username = self.password = r_phone
     elif password is not None and username is None and mobile is None:
         r_phone = random_phone_number()
         self.mobile = self.username = r_phone
         self.password = password
     else:
         self.mobile = mobile
         self.username = username
         self.password = password
     # 把初始化的用户信息打印出来以供阅读
     log(self.__repr__(), 'Init', 'info')
     print self
Example #29
0
 def __init__(self, mobile=None, username=None, password=None):
     u"""如果没有同时传入mobile,username和password,则随机生成,用户名与密码等于随机生成的手机号"""
     if mobile is None and username is None and password is None:
         r_phone = random_phone_number()
         self.mobile = self.username = self.password = r_phone
     elif password is not None and username is None and mobile is None:
         r_phone = random_phone_number()
         self.mobile = self.username = r_phone
         self.password = password
     else:
         self.mobile = mobile
         self.username = username
         self.password = password
     # 把初始化的用户信息打印出来以供阅读
     log(self.__repr__(), 'Init', 'info')
     print self
Example #30
0
 def bind(self):
     u"""商户审核通过后,绑定best,如果best绑定失败,换一个best账号,继续绑定,直到绑定成功,成功后可开通店铺"""
     param = {'user_id': self.userid,
              'user_name': self.mobile,
              'user_type': '2',
              'id_code': self.best_id,
              'BEST_user_id': self.best_id,
              'BEST_password': Encrypt(pwd_key='111111').encrypt(self.best_id, 'MD5')}
     res = self._signandpost(param, 'Bind')
     log('Merchant - bind', res, 'info')
     # print res
     if res != '{}':
         self._changebestid()
         res = self.bind()
     # print res
     return res
    def __handle_join_packet(self, packet: Packet):
        """
        When a Join packet received we should add a new node to our nodes array.
        In reality, there is a security level that forbids joining every node to our network.

        :param packet: Arrived register packet.


        :type packet Packet

        :return:
        """
        new_member_address = packet.get_source_server_address()
        log(f'New JOIN packet from Node({new_member_address}).')
        self.stream.add_node(new_member_address)
        self.children_addresses.append(new_member_address)
Example #32
0
 def bind(self):
     u"""商户审核通过后,绑定best,如果best绑定失败,换一个best账号,继续绑定,直到绑定成功,成功后可开通店铺"""
     param = {
         'user_id': self.userid,
         'user_name': self.mobile,
         'user_type': '2',
         'id_code': self.best_id,
         'BEST_user_id': self.best_id,
         'BEST_password':
         Encrypt(pwd_key='111111').encrypt(self.best_id, 'MD5')
     }
     res = self._signandpost(param, 'Bind')
     log('Merchant - bind', res, 'info')
     # print res
     if res != '{}':
         self._changebestid()
         res = self.bind()
     # print res
     return res
    def remove_node(self, node: Node):
        """
        Remove the node from our Stream.

        Warnings:
            1. Close the node after deletion.

        :param node: The node we want to remove.
        :type node: Node

        :return:
        """
        try:
            log(f"Something happened to Node({node.get_server_address()}).\n\tI'm Going to kill him. Right NOW!"
                )
            self.nodes.remove(node)
            node.close()
        except:
            return
 def __handle_advertise_request(self, packet: Packet) -> None:
     sender_address = packet.get_source_server_address()
     sender_semi_node = SemiNode(sender_address[0], sender_address[1])
     if sender_semi_node not in self.registered:
         log(f'Advertise Request from unregistered source({sender_address}).'
             )
         return
     advertised_address = self.__get_neighbour(sender_address)
     log(f'Advertising Node({advertised_address}) to Node({sender_address}).'
         )
     advertise_response_packet = PacketFactory.new_advertise_packet(
         AdvertiseType.RES, self.address, advertised_address)
     self.stream.add_message_to_out_buff(sender_address,
                                         advertise_response_packet,
                                         want_register=True)
     # Add to network_graph
     self.network_graph.add_node(sender_semi_node.get_ip(),
                                 sender_semi_node.get_port(),
                                 advertised_address)
def filter(msg, pb_id, client_id):
    new_msg = profanity.censor(msg)
    if new_msg != msg:
        addWarn(pb_id, client_id)

    now = time.time()
    if pb_id not in serverdata.clients:
        return None

    if "lastMsgTime" in serverdata.clients[pb_id]:
        count = serverdata.clients[pb_id]["cMsgCount"]
        smsgcount = serverdata.clients[pb_id]['cSameMsg']
        if now - serverdata.clients[pb_id]["lastMsgTime"] < 5:
            count += 1
            if count >= 2:
                addWarn(pb_id, client_id)
                count = 0
        elif now - serverdata.clients[pb_id]["lastMsgTime"] < 30:
            if serverdata.clients[pb_id]["lastMsg"] == msg:
                if len(msg) > 5:
                    smsgcount += 1
                    if smsgcount >= 3:
                        logger.log(pb_id + " | kicked for chat spam")
                        _ba.disconnect_client(client_id)
                        smsgcount = 0
                addWarn(pb_id, client_id)
            else:
                smsgcount = 0
        else:
            count = 0
            smsgcount = 0

        serverdata.clients[pb_id]['cMsgCount'] = count
        serverdata.clients[pb_id]['lastMsgTime'] = now
        serverdata.clients[pb_id]['lastMsg'] = msg
        serverdata.clients[pb_id]['cSameMsg'] = smsgcount
    else:
        serverdata.clients[pb_id]['cMsgCount'] = 0
        serverdata.clients[pb_id]['lastMsgTime'] = now
        serverdata.clients[pb_id]['lastMsg'] = msg
        serverdata.clients[pb_id]['cSameMsg'] = 0
    return new_msg
Example #36
0
def load(dataType, *corpusID):
	""" Loads an analysis for corpus and data type.
	
	>>> dump('melody', 'test', 'nonsense')
	True
	>>> load('melody', 'nonsense')
	'test'
	>>> load('melody', 'not_present') == None
	True
	"""
	corpusName = os.path.join(*corpusID)
	try:
		with open(_pathForDump(corpusID, dataType), 'r') as f:
			try:
				return pickle.load(f)
			except pickle.UnpicklingError:
				logger.log("%s's %s can not be unpickled." % ('/'.join(corpusName), dataType))
				return None
			except EOFError:
				# Previous write of dump failed.
				logger.log("Removing corrupted dump for %s' %s." % ('/'.join(corpusName), dataType))
				os.remove(_pathForDump(corpusID, dataType))
				return None
	except IOError:
		logger.log("Couldn't open file for reading.")
		return None