Added trace debugging branch; fixed colored names.

Author: AMorporkian

packet_stream.py

@@ -1,4 +1,5 @@
 import logging
+import pprint
 import zlib
 import datetime
 import packets
@@ -70,7 +71,10 @@ def check_packet(self):
                         z = zlib.decompressobj()
                         p_parsed.data = z.decompress(p_parsed.data)
                     except zlib.error:
-                        self.logger.warning("Decompression error in check_packet.")
+                        self.logger.error("Decompression error in check_packet.")
+                        self.logger.trace("Packet data:")
+                        for line in pprint.pformat(p_parsed):
+                            self.logger.trace(line)
                         raise
                 packet = Packet(packet_id=p_parsed.id, payload_size=p_parsed.payload_size, data=p_parsed.data,
                                 original_data=p, direction=self.direction)

plugins/core/__init__.py

@@ -2,4 +2,5 @@
 from admin_commands_plugin import *
 from command_plugin import *
 from player_manager import *
-from starbound_config_manager import *
+from starbound_config_manager import *
+from colored_names import *

plugins/core/admin_commands_plugin/admin_command_plugin.py

@@ -1,3 +1,5 @@
+import pprint
+import socket
 from twisted.internet import reactor
 from base_plugin import SimpleCommandPlugin, BasePlugin
 from plugins.core.player_manager import permissions, UserLevels
@@ -51,13 +53,21 @@ def whois(self, data):
     @permissions(UserLevels.MODERATOR)
     def promote(self, data):
         """Promotes/demoates a user to a specific rank. Syntax: /promote [username] [rank] (where rank is either: registered, moderator, admin, or guest))"""
+        self.logger.trace("Promote command received with the following data: %s" % ":".join(data))
         if len(data) > 0:
             name = " ".join(data[:-1])
+            self.logger.trace("Extracted the name %s in promote command." % name)
             rank = data[-1].lower()
+            self.logger.trace("Extracted the rank %s in the promote command." % rank)
             player = self.player_manager.get_by_name(name)
+            self.logger.trace("Player object in promote command, found by name, is %s." % str(player))
             if player is not None:
+                self.logger.trace("Player object was not None. Dump of player object follows.")
+                for line in pprint.pformat(player):
+                    self.logger.trace("\t"+line)
                 old_rank = player.access_level
                 if old_rank >= self.protocol.player.access_level:
+                    self.logger.trace("The old rank was greater or equal to the current rank. Sending a message and returning.")
                     self.protocol.send_chat_message(
                         "You cannot change that user's access level as they are at least at an equal level as you.")
                     return
@@ -70,23 +80,32 @@ def promote(self, data):
                 elif rank == "guest":
                     self.make_guest(player)
                 else:
+                    self.logger.trace("Non-existent rank. Returning with a help message.")
                     self.protocol.send_chat_message("No such rank!\n" + self.promote.__doc__)
                     return
 
+                self.logger.trace("Sending promotion message to promoter.")
                 self.protocol.send_chat_message("%s: %s -> %s" % (
                     player.colored_name(self.config.colors), str(UserLevels(old_rank)).split(".")[1],
                     rank.upper()))
-                self.factory.protocols[player.protocol].send_chat_message(
-                    "%s has promoted you to %s" % (
-                        self.protocol.player.colored_name(self.config.colors), rank.upper()))
+                self.logger.trace("Sending promotion message to promoted player.")
+                try:
+                    self.factory.protocols[player.protocol].send_chat_message(
+                        "%s has promoted you to %s" % (
+                            self.protocol.player.colored_name(self.config.colors), rank.upper()))
+                except KeyError:
+                    self.logger.trace("Promoted player is not logged in.")
             else:
+                self.logger.trace("Player wasn't found. Sending chat message to player.")
                 self.protocol.send_chat_message("Player not found!\n" + self.promote.__doc__)
                 return
         else:
+            self.logger.trace("Received blank promotion command. Sending help message.")
             self.protocol.send_chat_message(self.promote.__doc__)
 
     @permissions(UserLevels.OWNER)
     def make_guest(self, player):
+        self.logger.trace("Setting %s to GUEST", player.name)
         player.access_level = UserLevels.GUEST
         try:
             self.player_manager.session.commit()
@@ -96,6 +115,7 @@ def make_guest(self, player):
 
     @permissions(UserLevels.MODERATOR)
     def make_registered(self, player):
+        self.logger.trace("Setting %s to REGISTERED", player.name)
         player.access_level = UserLevels.REGISTERED
         try:
             self.player_manager.session.commit()
@@ -106,6 +126,7 @@ def make_registered(self, player):
     @permissions(UserLevels.ADMIN)
     def make_mod(self, player):
         player.access_level = UserLevels.MODERATOR
+        self.logger.trace("Setting %s to MODERATOR", player.name)
         try:
             self.player_manager.session.commit()
         except:
@@ -114,6 +135,7 @@ def make_mod(self, player):
 
     @permissions(UserLevels.OWNER)
     def make_admin(self, player):
+        self.logger.trace("Setting %s to ADMIN", player.name)
         player.access_level = UserLevels.ADMIN
         try:
             self.player_manager.session.commit()
@@ -144,12 +166,22 @@ def kick(self, data):
     @permissions(UserLevels.ADMIN)
     def ban(self, data):
         """Bans an IP (retrieved by /whois). Syntax: /ban [ip address]"""
-        ip = data[0]
-        self.player_manager.ban(ip)
-        self.protocol.send_chat_message("Banned IP: %s" % ip)
-        self.logger.warning("%s banned IP: %s", self.protocol.player.name, ip)
+        try:
+            ip = data[0]
+            socket.inet_aton(ip)
+            self.logger.debug("Banning IP address %s" % ip)
+            self.player_manager.ban(ip)
+            self.protocol.send_chat_message("Banned IP: %s" % ip)
+            self.logger.warning("%s banned IP: %s", self.protocol.player.name, ip)
+            return False
+        except socket.error:
+            self.ban_by_name(data)
         return False
 
+    def ban_by_name(self, data):
+        raise NotImplementedError
+
+
     @permissions(UserLevels.ADMIN)
     def bans(self, data):
         """Lists the currently banned IPs. Syntax: /bans"""

plugins/core/colored_names/colored_names.py

@@ -18,10 +18,14 @@ def activate(self):
     def on_chat_received(self, data):
         try:
             p = chat_received().parse(data.data)
+            print p
             sender = self.player_manager.get_logged_in_by_name(p.name)
+            print sender
             p.name = sender.colored_name(self.config.colors)
+            print p.name
             self.protocol.transport.write(build_packet(Packets.CHAT_RECEIVED, chat_received().build(p)))
-        except AttributeError:
+        except AttributeError as e:
+            self.logger.warning("Received AttributeError in colored_name. %s", str(e))
             self.protocol.transport.write(data.original_data)
         return False
 

plugins/core/player_manager/manager.py

@@ -110,8 +110,12 @@ class Player(Base):
     ips = relationship("IPAddress", order_by="IPAddress.id", backref="players")
 
     def colored_name(self, colors):
+        logger.trace("Building colored name.")
         color = colors[str(UserLevels(self.access_level)).split(".")[1].lower()]
+        logger.trace("Color is %s", color)
         name = self.name
+        logger.trace("Name is %s", name)
+        logger.trace("Returning the following data for colored name. %s:%s:%s", color, name, colors['default'])
         return color + name + colors["default"]
 
     @property

server.py

@@ -21,7 +21,7 @@
 from utility_functions import build_packet
 
 VERSION = "1.2.2"
-TRACE = False
+TRACE = True
 TRACE_LVL = 9
 logging.addLevelName(9, "TRACE")
 logging.Logger.trace = lambda s, m, *a, **k: s._log(TRACE_LVL, m, a, **k)
@@ -397,21 +397,23 @@ def send_chat_message(self, text, channel=0, world='', name=''):
         brackets, otherwise it will be displayed as `<name>`.
         :return: None
         """
-        logger.debug("Sent chat message with text: %s", text)
         if '\n' in text:
             lines = text.split('\n')
             for line in lines:
                 self.send_chat_message(line)
             return
+        logger.trace("Calling send_chat_message from player %s on channel %d on world '%s' with reported username of %s with message: %s", self.player.name, channel, world, name, text)
         chat_data = packets.chat_received().build(Container(chat_channel=channel,
                                                             world=world,
                                                             client_id=0,
                                                             name=name,
                                                             message=text.encode("utf-8")))
+        logger.trace("Built chat payload. Data: %s", chat_data.encode("hex"))
         chat_packet = build_packet(packets.Packets.CHAT_RECEIVED,
                                    chat_data)
+        logger.trace("Built chat packet. Data: %s", chat_packet.encode("hex"))
         self.transport.write(chat_packet)
-
+        logger.debug("Sent chat message with text: %s", text)
     def write(self, data):
         """
         Convenience method to send data to the client.