Changeset 2f6ae99


Ignore:
Timestamp:
Jun 5, 2009 7:46:26 PM (11 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
4a9b567e
Parents:
7725b9e
Message:

2009-06-05 sponge

  • BOB now cleans up tunnels, although they can take up to 5 minutes to disapear. This is due to the fact that the streaming lib doesn't actually remove the connections properly and kill them off when the manager is destroyed. I'm not certain if this is a bug, or a feature, but it sure is annoying, and you have to wait for the connections to time out. What should happen is the streaming lib should cause an IO error to the pending read or write.
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • apps/BOB/nbproject/private/private.xml

    r7725b9e r2f6ae99  
    22<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
    33    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/1"/>
     4    <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/1">
     5        <file>file:/root/NetBeansProjects/i2p.i2p/apps/BOB/src/net/i2p/BOB/BOB.java</file>
     6        <file>file:/root/NetBeansProjects/i2p.i2p/apps/BOB/src/net/i2p/BOB/DoCMDS.java</file>
     7        <file>file:/root/NetBeansProjects/i2p.i2p/apps/BOB/src/net/i2p/BOB/MUXlisten.java</file>
     8    </open-files>
    49</project-private>
  • apps/BOB/src/net/i2p/BOB/DoCMDS.java

    r7725b9e r2f6ae99  
    3737import net.i2p.data.Destination;
    3838import net.i2p.util.Log;
    39 import net.i2p.util.SimpleStore;
    4039
    4140/**
     
    9998        private static final String C_stop = "stop";
    10099        private static final String C_verify = "verify";
     100        private static final String C_visit = "visit";
    101101        private static final String C_zap = "zap";
    102102
     
    125125                {C_stop, C_stop + " * Stops the current nicknamed tunnel."},
    126126                {C_verify, C_verify + " BASE64_key * Verifies BASE64 destination."},
     127                {C_visit, C_visit + " * Thread dump to wrapper.log."},
    127128                {C_zap, C_zap + " * Shuts down BOB."},
    128129                {"", "COMMANDS: " + // this is ugly, but...
     
    149150                        C_stop + " " +
    150151                        C_verify + " " +
     152                        C_visit + " " +
    151153                        C_zap
    152154                },
     
    155157
    156158        /**
    157          * @parm LIVE
     159         * @param LIVE
    158160         * @param server
    159161         * @param props
     
    439441
    440442                                                                }
     443                                                        } else if (Command.equals(C_visit)) {
     444                                                                visitAllThreads();
     445                                                                out.println("OK ");
    441446                                                        } else if (Command.equals(C_getdest)) {
    442447                                                                if (ns) {
     
    12751280                                                                                        MUXlisten tunnel;
    12761281                                                                                        try {
    1277                                                                                                 while(!lock.compareAndSet(false, true)) {
     1282                                                                                                while (!lock.compareAndSet(false, true)) {
    12781283                                                                                                        // wait
    12791284                                                                                                }
     
    14461451                }
    14471452        }
     1453        // Debugging... None of this is normally used.
     1454
     1455        /**
     1456         *      Find the root thread group and print them all.
     1457         *
     1458         */
     1459        private void visitAllThreads() {
     1460                ThreadGroup root = Thread.currentThread().getThreadGroup().getParent();
     1461                while (root.getParent() != null) {
     1462                        root = root.getParent();
     1463                }
     1464
     1465                // Visit each thread group
     1466                visit(root, 0, root.getName());
     1467        }
     1468
     1469        /**
     1470         * Recursively visits all thread groups under `group' and dumps them.
     1471         * @param group ThreadGroup to visit
     1472         * @param level Current level
     1473         */
     1474        private static void visit(ThreadGroup group, int level, String tn) {
     1475                // Get threads in `group'
     1476                int numThreads = group.activeCount();
     1477                Thread[] threads = new Thread[numThreads * 2];
     1478                numThreads = group.enumerate(threads, false);
     1479                String indent = "------------------------------------".substring(0, level) + "-> ";
     1480                // Enumerate each thread in `group' and print it.
     1481                for (int i = 0; i < numThreads; i++) {
     1482                        // Get thread
     1483                        Thread thread = threads[i];
     1484                        System.out.println("BOB: "  + indent +  tn + ": " +thread.toString());
     1485                }
     1486
     1487                // Get thread subgroups of `group'
     1488                int numGroups = group.activeGroupCount();
     1489                ThreadGroup[] groups = new ThreadGroup[numGroups * 2];
     1490                numGroups = group.enumerate(groups, false);
     1491
     1492                // Recursively visit each subgroup
     1493                for (int i = 0; i < numGroups; i++) {
     1494                        visit(groups[i], level + 1, groups[i].getName());
     1495                }
     1496        }
    14481497}
  • apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

    r7725b9e r2f6ae99  
    7575                InputStream Iin = null;
    7676                OutputStream Iout = null;
     77                Thread t = null;
     78                Thread q = null;
    7779                try {
    7880                        die:
     
    114116                                        TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
    115117                                        TCPio conn_a = new TCPio(Iin, out /* , info, database */); // I2P -> app
    116                                         Thread t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
    117                                         Thread q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
     118                                        t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
     119                                        q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
    118120                                        // Fire!
    119121                                        t.start();
    120122                                        q.start();
    121                                         while (t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
     123                                        boolean spin = true;
     124                                        while (t.isAlive() && q.isAlive() && spin) { // AND is used here to kill off the other thread
    122125                                                try {
    123126                                                        Thread.sleep(10); //sleep for 10 ms
     
    125128                                                        break die;
    126129                                                }
     130                                                        try {
     131                                                                rlock();
     132                                                        } catch (Exception e) {
     133                                                                break die;
     134                                                        }
     135                                                        try {
     136                                                                spin = info.get("RUNNING").equals(Boolean.TRUE);
     137                                                        } catch (Exception e) {
     138                                                                try {
     139                                                                        runlock();
     140                                                                } catch (Exception e2) {
     141                                                                        break die;
     142                                                                }
     143                                                                break die;
     144                                                        }
    127145                                        }
    128146                                // System.out.println("I2PtoTCP: Going away...");
     
    133151                        } // die
    134152                } finally {
     153                        try {
     154                                t.interrupt();
     155                        } catch (Exception e) {
     156                        }
     157                        try {
     158                                q.interrupt();
     159                        } catch (Exception e) {
     160                        }
    135161                        try {
    136162                                in.close();
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    r7725b9e r2f6ae99  
    160160                                try {
    161161                                        tg = new ThreadGroup(N);
    162                                         die:
    163162                                        {
    164163                                                // toss the connections to a new threads.
     
    186185                                                        } catch (Exception e) {
    187186                                                                wunlock();
    188                                                                 break die;
     187                                                                break quit;
    189188                                                        }
    190189                                                } catch (Exception e) {
    191                                                         break die;
     190                                                        break quit;
    192191                                                }
    193192                                                try {
    194193                                                        wunlock();
    195194                                                } catch (Exception e) {
    196                                                         break die;
     195                                                        break quit;
    197196                                                }
    198197                                                boolean spin = true;
     
    201200                                                                Thread.sleep(1000); //sleep for 1 second
    202201                                                        } catch (InterruptedException e) {
    203                                                                 break die;
     202                                                                break quit;
    204203                                                        }
    205204                                                        try {
     
    209208                                                                } catch (Exception e) {
    210209                                                                        runlock();
    211                                                                         break die;
     210                                                                        break quit;
    212211                                                                }
    213212                                                        } catch (Exception e) {
    214                                                                 break die;
     213                                                                break quit;
    215214                                                        }
    216215                                                        try {
    217216                                                                runlock();
    218217                                                        } catch (Exception e) {
    219                                                                 break die;
     218                                                                break quit;
    220219                                                        }
    221220                                                }
    222                                                 /* cleared in the finally...
    223                                                 try {
    224                                                         wlock();
    225                                                         try {
    226                                                                 info.add("RUNNING", new Boolean(false));
    227                                                         } catch (Exception e) {
    228                                                                 wunlock();
    229                                                                 break die;
    230                                                         }
    231                                                 } catch (Exception e) {
    232                                                         break die;
    233                                                 }
    234                                                 try {
    235                                                         wunlock();
    236                                                 } catch (Exception e) {
    237                                                         break die;
    238                                                 }
    239                                                 */
    240221                                        } // die
    241222
     
    279260                        }
    280261
    281                         try {
    282                                 socketManager.destroySocketManager();
    283                         } catch (Exception e) {
    284                                 // nop
    285                         }
    286262                        // Some grace time.
    287263                        try {
     
    294270                        if (tg != null) {
    295271                                String boner = tg.getName();
     272                                System.out.println("BOB: MUXlisten: Starting thread collection for: " + boner);
    296273                                _log.warn("BOB: MUXlisten: Starting thread collection for: " + boner);
    297274                                // tg.interrupt(); // give my stuff a small smack again.
    298275                                if (tg.activeCount() + tg.activeGroupCount() != 0) {
     276                                        visit(tg, 0, boner);
    299277                                        int foo = tg.activeCount() + tg.activeGroupCount();
    300278                                        // hopefully no longer needed!
    301                                         // int bar = foo;
    302                                         // System.out.println("BOB: MUXlisten: Waiting on threads for " + boner);
    303                                         // System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
    304                                         // visit(tg, 0, boner);
    305                                         // System.out.println("BOB: MUXlisten: ThreadGroup dump END " + boner + "\n");
     279                                        int bar = foo;
     280                                        System.out.println("BOB: MUXlisten: Waiting on threads for " + boner);
     281                                        System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
     282                                        visit(tg, 0, boner);
     283                                        System.out.println("BOB: MUXlisten: ThreadGroup dump END " + boner + "\n");
    306284                                        // Happily spin forever :-(
    307285                                        while (foo != 0) {
    308286                                                foo = tg.activeCount() + tg.activeGroupCount();
    309                                                 //      if (foo != bar) {
    310                                                 //              System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
    311                                                 //              visit(tg, 0, boner);
    312                                                 //              System.out.println("BOB: MUXlisten: ThreadGroup dump END " + boner + "\n");
    313                                                 //      }
    314                                                 // bar = foo;
     287                                                if (foo != bar && foo != 0) {
     288                                                        System.out.println("\nBOB: MUXlisten: ThreadGroup dump BEGIN " + boner);
     289                                                        visit(tg, 0, boner);
     290                                                        System.out.println("BOB: MUXlisten: ThreadGroup dump END " + boner + "\n");
     291                                                }
     292                                                bar = foo;
    315293                                                try {
    316294                                                        Thread.sleep(100); //sleep for 100 ms (One tenth second)
     
    320298                                        }
    321299                                }
     300                                System.out.println("BOB: MUXlisten: Threads went away. Success: " + boner);
    322301                                _log.warn("BOB: MUXlisten: Threads went away. Success: " + boner);
    323302                                tg.destroy();
     
    325304                                tg = null;
    326305                        }
     306                        try {
     307                                socketManager.destroySocketManager();
     308                        } catch (Exception e) {
     309                                // nop
     310                        }
     311
    327312                }
    328313        }
  • apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

    r7725b9e r2f6ae99  
    4646
    4747        private I2PSocket I2P;
    48         // private NamedDB info,  database;
     48        private NamedDB info,  database;
    4949        private Socket sock;
    5050        private I2PSocketManager socketManager;
     
    109109        }
    110110
     111        private void rlock() throws Exception {
     112                database.getReadLock();
     113                info.getReadLock();
     114        }
     115
     116        private void runlock() throws Exception {
     117                database.releaseReadLock();
     118                info.releaseReadLock();
     119        }
     120
    111121        /**
    112122         * TCP stream to I2P stream thread starter
     
    119129                InputStream in = null;
    120130                OutputStream out = null;
     131                Thread t = null;
     132                Thread q = null;
    121133                try {
    122134                        try {
     
    146158                                                TCPio conn_c = new TCPio(in, Iout /*, info, database */); // app -> I2P
    147159                                                TCPio conn_a = new TCPio(Iin, out /*, info, database */); // I2P -> app
    148                                                 Thread t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
    149                                                 Thread q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
     160                                                t = new Thread(conn_c, Thread.currentThread().getName() + " TCPioA");
     161                                                q = new Thread(conn_a, Thread.currentThread().getName() + " TCPioB");
    150162                                                // Fire!
    151163                                                t.start();
    152164                                                q.start();
     165                                                boolean spin = true;
    153166                                                while (t.isAlive() && q.isAlive()) { // AND is used here to kill off the other thread
    154167                                                        Thread.sleep(10); //sleep for 10 ms
     168                                                        rlock();
     169                                                        spin = info.get("RUNNING").equals(Boolean.TRUE);
     170                                                        runlock();
    155171                                                }
    156 
    157172                                        } catch (I2PException e) {
    158173                                                Emsg("ERROR " + e.toString(), out);
     
    173188                } finally {
    174189                        try {
     190                                t.interrupt();
     191                        } catch (Exception e) {
     192                        }
     193                        try {
     194                                q.interrupt();
     195                        } catch (Exception e) {
     196                        }
     197                        try {
    175198                                in.close();
    176199                        } catch (Exception e) {
  • history.txt

    r7725b9e r2f6ae99  
     12009-06-05 sponge
     2    * BOB now cleans up tunnels, although they can take up to 5 minutes to
     3      disapear. This is due to the fact that the streaming lib doesn't
     4      actually remove the connections properly and kill them off when the
     5      manager is destroyed. I'm not certain if this is a bug, or a feature,
     6      but it sure is annoying, and you have to wait for the connections to
     7      time out. What should happen is the streaming lib should cause an IO
     8      error to the pending read or write.
     9
    1102009-05-30 zzz
    211    * Console:
  • router/java/src/net/i2p/router/RouterVersion.java

    r7725b9e r2f6ae99  
    1919    public final static String ID = "Monotone";
    2020    public final static String VERSION = CoreVersion.VERSION;
    21     public final static long BUILD = 10;
     21    public final static long BUILD = 11;
    2222    /** for example "-test" */
    2323    public final static String EXTRA = "";
Note: See TracChangeset for help on using the changeset viewer.