Changeset 2025

Timestamp:

12/18/07 08:30:57 (3 years ago)

Author:

dugwyler

Message:

Low-priority packet limiting functionality. Chat packets are always sent last in a cluster, and the number that can be sent per cluster can now be limited. This should prevent server recycles when the cap is set up properly, at the cost of a small delay in messages sent when there are a great deal being sent out. Note that the cap is by default extremely high (100 chat packets allowed every 75ms) so it should not affect normal bot operations in any way. Bots needing to utilize the functionality to its fullest should call BotAction's setLowPriorityPacketCap(int).

Files:

• trunk/twcore/src/twcore/core/net/GamePacketGenerator.java (modified) (19 diffs)

trunk/twcore/src/twcore/core/net/GamePacketGenerator.java

@@ -16 +16 @@
 public class GamePacketGenerator {
 
-    private Timer                 m_timer;          // Schedules clustered packets
-    private TimerTask             m_timerTask;      // Clustered packet send task
-    private List<ByteArray>       m_messageList;    // Msgs waiting for clustered send
-    private SSEncryption          m_ssEncryption;   // Encryption class
-    private Sender                m_outboundQueue;  // Outgoing packet queue
-    private int                   m_serverTimeDifference;   // Diff (*tinfo)
-    private ReliablePacketHandler m_reliablePacketHandler;  // Handles reliable sends
-
-    private long                  m_sendDelay = 75; // Delay between cluster sends
+    private Timer                  m_timer;          // Schedules clustered packets
+    private TimerTask              m_timerTask;      // Clustered packet send task
+    private DelayedPacketList<ByteArray> m_messageList;  // Packets waiting to be sent in clusters
+    private SSEncryption           m_ssEncryption;   // Encryption class
+    private Sender                 m_outboundQueue;  // Outgoing packet queue
+    private int                    m_serverTimeDifference;   // Diff (*tinfo)
+    private ReliablePacketHandler  m_reliablePacketHandler;  // Handles reliable sends
+
+    private long                   m_sendDelay = 75;         // Delay between packet sends
+    private final static int       DEFAULT_PACKET_CAP = 100; // Default # low-priority packets
+                                                             // allowed per clustered send
 
     /**
@@ -37 +39 @@
         m_ssEncryption = ssEncryption;
         m_outboundQueue = outboundQueue;
-        m_messageList = Collections.synchronizedList(new LinkedList<ByteArray>());
+        m_messageList = new DelayedPacketList<ByteArray>( DEFAULT_PACKET_CAP );
 
         m_timerTask = new TimerTask(){
+            int size;
             public void run(){
-                int         size;
 
                 synchronized (m_messageList) {
                     size = m_messageList.size();
                     if( size == 1 ){
-                        sendReliableMessage( m_messageList.remove(0) );
+                        sendReliableMessage( m_messageList.getNextPacket() );
                     } else if( size > 1 ){
                         sendClusteredPacket();
@@ -75 +77 @@
 
     /**
+     * Sets the max number of lower-priority (aka chat) packets that can
+     * be sent per clustered send.
+     * @param cap Max # lower-priority packets allowed to be sent per clustered send
+     */
+    public void setPacketCap( int cap ){
+        m_messageList.setPacketCap( cap );
+    }
+
+    /**
      * Adds a packet to the standard outgoing queue.
      * @param array Packet to add
@@ -80 +91 @@
     public void composePacket( int[] array ){
 
-        m_messageList.add( new ByteArray( array ) );
+        m_messageList.addNormalPacket( new ByteArray( array ) );
     }
 
@@ -89 +100 @@
     public void composePacket( byte[] array ){
 
-        m_messageList.add( new ByteArray( array ) );
+        m_messageList.addNormalPacket( new ByteArray( array ) );
     }
 
@@ -98 +109 @@
     public void composePacket( ByteArray bytearray ){
 
-        m_messageList.add( bytearray );
+        m_messageList.addNormalPacket( bytearray );
+    }
+
+    /**
+     * Adds a packet to the outgoing queue with low priority.  The number of
+     * such packets allowed to be transmitted out per clustered send is capped,
+     * and can be set with setPacketCap(int).
+     * @param bytearray Packet to add
+     * @see #setPacketCap(int)
+     */
+    public void composeLowPriorityPacket( ByteArray bytearray ){
+
+        m_messageList.addCappedPacket( bytearray );
+    }
+
+    /**
+     * Adds a packet to the outgoing queue with low priority.  The number of
+     * such packets allowed to be transmitted out per clustered send is capped,
+     * and can be set with setPacketCap(int).
+     * @param array Packet to add
+     * @see #setPacketCap(int)
+     */
+    public void composeLowPriorityPacket( int[] array ){
+
+        m_messageList.addCappedPacket( new ByteArray( array ) );
+    }
+
+    /**
+     * Adds a packet to the outgoing queue with low priority.  The number of
+     * such packets allowed to be transmitted out per clustered send is capped,
+     * and can be set with setPacketCap(int).
+     * @param array Packet to add
+     * @see #setPacketCap(int)
+     */
+    public void composeLowPriorityPacket( byte[] array ){
+
+        m_messageList.addCappedPacket( new ByteArray( array ) );
     }
 
@@ -104 +151 @@
      * Adds a packet to the immediate outgoing queue, ignoring any other packets
      * in the standard queue it could be clustered with.  Fast but not as efficient.
+     * Packets sent in this manner are not sent reliably.
      * @param array Packet to add
      */
@@ -114 +162 @@
      * Adds a packet to the immediate outgoing queue, ignoring any other packets
      * in the standard queue it could be clustered with.  Fast but not as efficient.
+     * Packets sent in this manner are not sent reliably.
      * @param array Packet to add
      */
@@ -124 +173 @@
      * Adds a packet to the immediate outgoing queue, ignoring any other packets
      * in the standard queue it could be clustered with.  Fast but not as efficient.
+     * Packets sent in this manner are not sent reliably.
      * @param bytearray Packet to add
      * @param size Size of packet
@@ -135 +185 @@
      * Adds a packet to the immediate high-priority outgoing queue, ignoring any
      * other packets in the standard queue it could be clustered with and placing
-     * it at the head of the immediate queue.
+     * it at the head of the immediate queue.  Packets sent in this manner are not
+     * sent reliably.
      * @param array Packet to add
      */
@@ -146 +197 @@
      * Adds a packet to the immediate high-priority outgoing queue, ignoring any
      * other packets in the standard queue it could be clustered with and placing
-     * it at the head of the immediate queue.
+     * it at the head of the immediate queue.  Packets sent in this manner are not
+     * sent reliably.
      * @param array Packet to add
      */
@@ -157 +209 @@
      * Adds a packet to the immediate high-priority outgoing queue, ignoring any
      * other packets in the standard queue it could be clustered with and placing
-     * it at the head of the immediate queue.
+     * it at the head of the immediate queue.  Packets sent in this manner are not
+     * sent reliably.
      * @param bytearray Packet to add
      * @param size Size of packet
@@ -285 +338 @@
         sendReliableMessage( bytearray );
     }
-    
-    /**
-     * Sends the registration data if the server asks for it. This information is mostly build up 
+
+    /**
+     * Sends the registration data if the server asks for it. This information is mostly build up
      * from the properties of setup.cfg ([registration] tag). The registry variables are replaced by "TWCore"
      * since we want to keep TWCore cross-platform.
-     * 
+     *
      * @param realname Real name
      * @param email E-mail address
@@ -333 +386 @@
                         726             40              System\CurrentControlSet\Services\Class\MEDIA\0004
                 */
-        
+
         ByteArray bytearray = new ByteArray(766);
-        
+
         bytearray.addByte( 0x17 );                                              // Type
         bytearray.addPaddedString(realname, 32);                // Real name
@@ -364 +417 @@
         bytearray.addPaddedString("TWCore", 40);                //                              ...\MEDIA\0003
         bytearray.addPaddedString("TWCore", 40);                //                              ...\MEDIA\0004
-        
+
         this.sendMassiveChunkPacket( bytearray );
     }
@@ -473 +526 @@
         bytearray.addByte( 0x00 );          // Terminator
 
-        composePacket( bytearray );
+        composeLowPriorityPacket( bytearray );
     }
 
@@ -495 +548 @@
             // We might need to send more than one packet if the total of all messages
             // is longer than 500 bytes.
+            m_messageList.resetCap();
+
             while( done == false ){
 
                 // We now need to add as many as we can before we fill up the 500 bytes.
-                if( m_messageList.size() > 0 ){
-                    tempMessage = m_messageList.remove(0);
+                if( m_messageList.cappedSize() > 0 ){
+                    tempMessage = m_messageList.getNextPacket();
                     nextSize = tempMessage.size();
                 } else {
@@ -511 +566 @@
                     bytearray.addByteArray( tempMessage );
 
-                    if( m_messageList.size() > 0 ){
-                        tempMessage = m_messageList.remove(0);
+                    if( m_messageList.cappedSize() > 0 ){
+                        tempMessage = m_messageList.getNextPacket();
                         sizeLeft -= nextSize + 1;
                         nextSize = tempMessage.size();
@@ -717 +772 @@
     }
 
+    /**
+     * Implementation to send out most packets as normal, while placing a cap
+     * on the number of less-important packets (generally messages) that are
+     * sent out per run of the cluster packet composition timer.
+     * @author dugwyler
+     * @param <E>
+     */
+    private class DelayedPacketList<E> {
+        private List<E> m_normalPacketList;
+        private List<E> m_cappedPacketList;
+        private int m_packetCap;
+        private int m_remainingCap;
+
+        public DelayedPacketList( int packetCap ) {
+            m_normalPacketList = Collections.synchronizedList(new LinkedList<E>());
+            m_cappedPacketList = Collections.synchronizedList(new LinkedList<E>());
+            m_packetCap = packetCap;
+            m_remainingCap = packetCap;
+        }
+
+        public void setPacketCap( int packetCap ) {
+            m_packetCap = packetCap;
+        }
+
+        public void resetCap() {
+            m_remainingCap = m_packetCap;
+        }
+
+        public void addNormalPacket( E packet ) {
+            m_normalPacketList.add( packet );
+        }
+
+        public void addCappedPacket( E packet ) {
+            m_cappedPacketList.add( packet );
+        }
+
+        public E getNextPacket( ) {
+            if( m_normalPacketList.isEmpty() == false )
+                return m_normalPacketList.remove( 0 );
+            else {
+                m_remainingCap--;
+                return m_cappedPacketList.remove( 0 );
+            }
+        }
+
+        public int size() {
+            return m_normalPacketList.size() + m_cappedPacketList.size();
+        }
+
+        public int cappedSize() {
+            return m_normalPacketList.size() + Math.min( m_cappedPacketList.size(), m_packetCap );
+        }
+    }
 }