Changeset b0313bd6


Ignore:
Timestamp:
Sep 27, 2008 4:00:06 PM (12 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
61749aa
Parents:
dd7d993
Message:

disapproval of revision '7ed18fd4c3a5430150a2d76bfe202bc491115974'

Files:
1 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • apps/i2ptunnel/java/src/net/i2p/i2ptunnel/I2PTunnelServer.java

    rdd7d993 rb0313bd6  
    1313import java.net.Socket;
    1414import java.net.SocketException;
    15 import java.net.SocketTimeoutException;
    1615import java.util.Iterator;
    1716import java.util.Properties;
     
    221220                        _log.error("Error accepting", ce);
    222221                    // not killing the server..
    223                 } catch(SocketTimeoutException ste) {
    224                         // ignored, we never set the timeout
    225222                }
    226223            }
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PServerSocket.java

    rdd7d993 rb0313bd6  
    33import java.net.ConnectException;
    44
    5 import java.net.SocketTimeoutException;
    65import net.i2p.I2PException;
    76
     
    1110 */
    1211public interface I2PServerSocket {
    13 
    1412    /**
    1513     * Closes the socket.
     
    2725     *         from the data available (aka the I2PSession closed, etc)
    2826     * @throws ConnectException if the I2PServerSocket is closed
    29          * @throws SocketTimeoutException
    30          */
    31         public I2PSocket accept() throws I2PException, ConnectException, SocketTimeoutException;
    32 
    33         /**
    34          * Set Sock Option accept timeout
    35          * @param x
    36          */
    37         public void setSoTimeout(long x);
    38 
    39         /**
    40          * Get Sock Option accept timeout
    41          * @return timeout
    4227     */
    43         public long getSoTimeout();
     28    public I2PSocket accept() throws I2PException, ConnectException;
    4429
    4530    /**
  • apps/ministreaming/java/src/net/i2p/client/streaming/I2PServerSocketImpl.java

    rdd7d993 rb0313bd6  
    1818 */
    1919class I2PServerSocketImpl implements I2PServerSocket {
    20 
    2120    private final static Log _log = new Log(I2PServerSocketImpl.class);
    2221    private I2PSocketManager mgr;
    2322    /** list of sockets waiting for the client to accept them */
    2423    private List pendingSockets = Collections.synchronizedList(new ArrayList(4));
     24   
    2525    /** have we been closed */
    2626    private volatile boolean closing = false;
     27   
    2728    /** lock on this when accepting a pending socket, and wait on it for notification of acceptance */
    2829    private Object socketAcceptedLock = new Object();
     
    3031    private Object socketAddedLock = new Object();
    3132   
    32         /**
    33          * Set Sock Option accept timeout stub, does nothing
    34          * @param x
    35          */
    36         public void setSoTimeout(long x) {
    37         }
    38 
    39         /**
    40          * Get Sock Option accept timeout stub, does nothing
    41          * @return timeout
    42          */
    43         public long getSoTimeout() {
    44                 return -1;
    45         }
    46 
    4733    public I2PServerSocketImpl(I2PSocketManager mgr) {
    4834        this.mgr = mgr;
     
    6248     */
    6349    public I2PSocket accept() throws I2PException, ConnectException {
    64                 if(_log.shouldLog(Log.DEBUG)) {
     50        if (_log.shouldLog(Log.DEBUG))
    6551            _log.debug("accept() called, pending: " + pendingSockets.size());
    66                 }
     52       
    6753        I2PSocket ret = null;
    6854       
    6955        while ( (ret == null) && (!closing) ){
    7056            while (pendingSockets.size() <= 0) {
    71                                 if(closing) {
    72                                         throw new ConnectException("I2PServerSocket closed");
    73                                 }
     57                if (closing) throw new ConnectException("I2PServerSocket closed");
    7458                try {
    7559                    synchronized(socketAddedLock) {
    7660                        socketAddedLock.wait();
    7761                    }
    78                                 } catch(InterruptedException ie) {
    79                                 }
     62                } catch (InterruptedException ie) {}
    8063            }
    8164            synchronized (pendingSockets) {
     
    9174        }
    9275       
    93                 if(_log.shouldLog(Log.DEBUG)) {
     76        if (_log.shouldLog(Log.DEBUG))
    9477            _log.debug("TIMING: handed out accept result " + ret.hashCode());
    95                 }
    9678        return ret;
    9779    }
     
    10789     */
    10890    public boolean addWaitForAccept(I2PSocket s, long timeoutMs) {
    109                 if(_log.shouldLog(Log.DEBUG)) {
     91        if (_log.shouldLog(Log.DEBUG))
    11092            _log.debug("addWaitForAccept [new socket arrived [" + s.toString() + "], pending: " + pendingSockets.size());
    111                 }
     93       
    11294        if (closing) {
    113                         if(_log.shouldLog(Log.WARN)) {
     95            if (_log.shouldLog(Log.WARN))
    11496                _log.warn("Already closing the socket");
    115                         }
    11697            return false;
    11798        }
     
    130111            long now = clock.now();
    131112            if (now >= end) {
    132                                 if(_log.shouldLog(Log.INFO)) {
     113                if (_log.shouldLog(Log.INFO))
    133114                    _log.info("Expired while waiting for accept (time elapsed =" + (now - start) + "ms) for socket " + s.toString());
    134                                 }
    135115                pendingSockets.remove(s);
    136116                return false;
    137117            }
    138118            if (closing) {
    139                                 if(_log.shouldLog(Log.WARN)) {
     119                if (_log.shouldLog(Log.WARN))
    140120                    _log.warn("Server socket closed while waiting for accept");
    141                                 }
    142121                pendingSockets.remove(s);
    143122                return false;
     
    148127                    socketAcceptedLock.wait(remaining);
    149128                }
    150                         } catch(InterruptedException ie) {
    151                         }
     129            } catch (InterruptedException ie) {}
    152130        }
    153131        long now = clock.now();
    154                 if(_log.shouldLog(Log.DEBUG)) {
     132        if (_log.shouldLog(Log.DEBUG))
    155133            _log.info("Socket accepted after " + (now-start) + "ms for socket " + s.toString());
    156                 }
    157134        return true;
    158135    }
     
    170147    }
    171148   
    172         public I2PSocketManager getManager() {
    173                 return mgr;
    174         }
     149    public I2PSocketManager getManager() { return mgr; }
    175150}
  • apps/ministreaming/java/src/net/i2p/client/streaming/StreamSinkServer.java

    rdd7d993 rb0313bd6  
    66import java.io.InputStream;
    77import java.net.ConnectException;
    8 import java.net.SocketTimeoutException;
    98import java.util.Properties;
    109
     
    2221 */
    2322public class StreamSinkServer {
    24 
    2523    private Log _log;
    2624    private String _sinkDir;
     
    3937        this(sinkDir, ourDestFile, null, -1, 3);
    4038    }
    41 
    4239    public StreamSinkServer(String sinkDir, String ourDestFile, String i2cpHost, int i2cpPort, int handlers) {
    4340        _sinkDir = sinkDir;
     
    5653    public void runServer() {
    5754        I2PSocketManager mgr = null;
    58                 if(_i2cpHost != null) {
     55        if (_i2cpHost != null)
    5956            mgr = I2PSocketManagerFactory.createManager(_i2cpHost, _i2cpPort, new Properties());
    60                 } else {
     57        else
    6158            mgr = I2PSocketManagerFactory.createManager();
    62                 }
    6359        Destination dest = mgr.getSession().getMyDestination();
    64                 if(_log.shouldLog(Log.INFO)) {
     60        if (_log.shouldLog(Log.INFO))
    6561            _log.info("Listening for connections on: " + dest.calculateHash().toBase64());
    66                 }
    6762        FileOutputStream fos = null;
    6863        try {
     
    7671            return;
    7772        } finally {
    78                         if(fos != null) {
    79                                 try {
    80                                         fos.close();
    81                                 } catch(IOException ioe) {
    82                                 }
    83                         }
     73            if (fos != null) try { fos.close(); } catch (IOException ioe) {}
    8474        }
    8575       
     
    10292     */
    10393    private class ClientRunner implements Runnable {
    104 
    10594        private I2PServerSocket _socket;
    106 
    10795        public ClientRunner(I2PServerSocket socket) {
    10896            _socket = socket;
    10997        }
    110 
    11198        public void run() {
    11299            while (true) {
    113100                try {
    114101                    I2PSocket socket = _socket.accept();
    115                                         if(socket != null) {
     102                    if (socket != null)
    116103                        handle(socket);
    117                                         }
    118104                } catch (I2PException ie) {
    119105                    _log.error("Error accepting connection", ie);
     
    122108                    _log.error("Connection already dropped", ce);
    123109                    return;
    124                                 } catch(SocketTimeoutException ste) {
    125                                         // ignored
    126110                }       
    127111            }
     
    132116            try {
    133117                File sink = new File(_sinkDir);
    134                                 if(!sink.exists()) {
     118                if (!sink.exists())
    135119                    sink.mkdirs();
    136                                 }
    137120                File cur = File.createTempFile("clientSink", ".dat", sink);
    138121                fos = new FileOutputStream(cur);
    139                                 if(_log.shouldLog(Log.DEBUG)) {
     122                if (_log.shouldLog(Log.DEBUG))
    140123                    _log.debug("Writing to " + cur.getAbsolutePath());
    141                                 }
    142124            } catch (IOException ioe) {
    143125                _log.error("Error creating sink", ioe);
     
    154136                    //_fos.write(buf, 0, read);
    155137                    written += read;
    156                                         if(_log.shouldLog(Log.DEBUG)) {
     138                    if (_log.shouldLog(Log.DEBUG))
    157139                        _log.debug("read and wrote " + read + " (" + written + ")");
    158140                }
    159                                 }
    160141                fos.write(("written: [" + written + "]\n").getBytes());
    161142                long lifetime = System.currentTimeMillis() - start;
     
    164145                _log.error("Error writing the sink", ioe);
    165146            } finally {
    166                                 if(fos != null) {
    167                                         try {
    168                                                 fos.close();
    169                                         } catch(IOException ioe) {
    170                                         }
    171                                 }
    172                                 if(sock != null) {
    173                                         try {
    174                                                 sock.close();
    175                                         } catch(IOException ioe) {
    176                                         }
    177                                 }
     147                if (fos != null) try { fos.close(); } catch (IOException ioe) {}
     148                if (sock != null) try { sock.close(); } catch (IOException ioe) {}
    178149                _log.debug("Client socket closed");
    179150            }
     
    204175                    try {
    205176                        handlers = Integer.parseInt(args[4]);
    206                                         } catch(NumberFormatException nfe) {
    207                                         }
     177                    } catch (NumberFormatException nfe) {}
    208178                }
    209179                try {
     
    217187                System.out.println("Usage: StreamSinkServer [i2cpHost i2cpPort] sinkDir ourDestFile [handlers]");
    218188        }
    219                 if(server != null) {
     189        if (server != null)
    220190            server.runServer();
    221191    }
    222192}
    223 }
  • apps/streaming/java/src/net/i2p/client/streaming/ConnectionHandler.java

    rdd7d993 rb0313bd6  
    11package net.i2p.client.streaming;
    22
    3 import java.net.SocketTimeoutException;
    43import java.util.ArrayList;
    54import java.util.List;
  • apps/streaming/java/src/net/i2p/client/streaming/ConnectionManager.java

    rdd7d993 rb0313bd6  
    2222 */
    2323public class ConnectionManager {
    24 
    2524    private I2PAppContext _context;
    2625    private Log _log;
     
    4140    private volatile int _numWaiting;
    4241    private Object _connectionLock;
    43         private long SoTimeout;
    4442   
    4543    public ConnectionManager(I2PAppContext context, I2PSession session, int maxConcurrent, ConnectionOptions defaultOptions) {
     
    6159        _defaultOptions = defaultOptions;
    6260        _numWaiting = 0;
    63                 /** Socket timeout for accept() */
    64                 SoTimeout = -1;
    65 
    6661        _context.statManager().createRateStat("stream.con.lifetimeMessagesSent", "How many messages do we send on a stream?", "Stream", new long[] { 60*60*1000, 24*60*60*1000 });
    6762        _context.statManager().createRateStat("stream.con.lifetimeMessagesReceived", "How many messages do we receive on a stream?", "Stream", new long[] { 60*60*1000, 24*60*60*1000 });
     
    8176        }
    8277    }
    83 
    8478    /**
    8579     * not guaranteed to be unique, but in case we receive more than one packet
     
    9084            for (Iterator iter = _connectionByInboundId.values().iterator(); iter.hasNext(); ) {
    9185                Connection con = (Connection)iter.next();
    92                                 if(DataHelper.eq(con.getSendStreamId(), id)) {
     86                if (DataHelper.eq(con.getSendStreamId(), id))
    9387                    return con;
    9488            }
    9589        }
    96                 }
    9790        return null;
    9891    }
    9992   
    100         /**
    101          * Set the socket accept() timeout.
    102          * @param x
    103          */
    104         public void MsetSoTimeout(long x) {
    105                 SoTimeout = x;
    106         }
    107 
    108         /**
    109          * Get the socket accept() timeout.
    110          * @return
    111          */
    112         public long MgetSoTimeout() {
    113                 return SoTimeout;
    114         }
    115 
    11693    public void setAllowIncomingConnections(boolean allow) {
    11794        _connectionHandler.setActive(allow);
    11895    }
    119 
    12096    /** should we acceot connections, or just reject everyone? */
    12197    public boolean getAllowIncomingConnections() {
     
    138114            total = _connectionByInboundId.size();
    139115            for (Iterator iter = _connectionByInboundId.values().iterator(); iter.hasNext(); ) {
    140                                 if(((Connection)iter.next()).getIsConnected()) {
     116                if ( ((Connection)iter.next()).getIsConnected() )
    141117                    active++;
    142118            }
    143                         }
    144119            if (locked_tooManyStreams()) {
    145120                reject = true;
     
    161136       
    162137        if (reject) {
    163                         if(_log.shouldLog(Log.WARN)) {
    164                                 _log.warn("Refusing connection since we have exceeded our max of " + _maxConcurrentStreams + " connections");
    165                         }
     138            if (_log.shouldLog(Log.WARN))
     139                _log.warn("Refusing connection since we have exceeded our max of "
     140                          + _maxConcurrentStreams + " connections");
    166141            PacketLocal reply = new PacketLocal(_context, synPacket.getOptionalFrom());
    167142            reply.setFlag(Packet.FLAG_RESET);
     
    189164        return con;
    190165    }
     166   
    191167    private static final long DEFAULT_STREAM_DELAY_MAX = 10*1000;
    192168   
     
    201177        long receiveId = _context.random().nextLong(Packet.MAX_STREAM_ID-1)+1;
    202178        long expiration = _context.clock().now() + opts.getConnectTimeout();
    203                 if(opts.getConnectTimeout() <= 0) {
     179        if (opts.getConnectTimeout() <= 0)
    204180            expiration = _context.clock().now() + DEFAULT_STREAM_DELAY_MAX;
    205                 }
    206181        _numWaiting++;
    207182        while (true) {
    208183            long remaining = expiration - _context.clock().now();
    209184            if (remaining <= 0) {
    210                                 if(_log.shouldLog(Log.WARN)) {
    211                                         _log.warn("Refusing to connect since we have exceeded our max of " + _maxConcurrentStreams + " connections");
    212                                 }
     185                if (_log.shouldLog(Log.WARN))
     186                _log.warn("Refusing to connect since we have exceeded our max of "
     187                          + _maxConcurrentStreams + " connections");
    213188                _numWaiting--;
    214189                return null;
     
    219194                    // allow a full buffer of pending/waiting streams
    220195                    if (_numWaiting > _maxConcurrentStreams) {
    221                                                 if(_log.shouldLog(Log.WARN)) {
    222                                                         _log.warn("Refusing connection since we have exceeded our max of " + _maxConcurrentStreams + " and there are " + _numWaiting + " waiting already");
    223                                                 }
     196                        if (_log.shouldLog(Log.WARN))
     197                            _log.warn("Refusing connection since we have exceeded our max of "
     198                                      + _maxConcurrentStreams + " and there are " + _numWaiting
     199                                      + " waiting already");
    224200                        _numWaiting--;
    225201                        return null;
     
    227203                   
    228204                    // no remaining streams, lets wait a bit
    229                                         try {
    230                                                 _connectionLock.wait(remaining);
    231                                         } catch(InterruptedException ie) {
    232                                         }
     205                    try { _connectionLock.wait(remaining); } catch (InterruptedException ie) {}
    233206                } else {
    234207                    con = new Connection(_context, this, _schedulerChooser, _outboundQueue, _conPacketHandler, opts);
     
    252225            con.waitForConnect();
    253226        }
    254                 if(_numWaiting > 0) {
     227        if (_numWaiting > 0)
    255228            _numWaiting--;
    256                 }
     229       
    257230        _context.statManager().addRateData("stream.connectionCreated", 1, 0);
    258231        return con;
     
    260233
    261234    private boolean locked_tooManyStreams() {
    262                 if(_maxConcurrentStreams <= 0) {
    263                         return false;
    264                 }
    265                 if(_connectionByInboundId.size() < _maxConcurrentStreams) {
    266                         return false;
    267                 }
     235        if (_maxConcurrentStreams <= 0) return false;
     236        if (_connectionByInboundId.size() < _maxConcurrentStreams) return false;
    268237        int active = 0;
    269238        for (Iterator iter = _connectionByInboundId.values().iterator(); iter.hasNext(); ) {
    270239            Connection con = (Connection)iter.next();
    271                         if(con.getIsConnected()) {
     240            if (con.getIsConnected())
    272241                active++;
    273242        }
    274                 }
    275        
    276                 if((_connectionByInboundId.size() > 100) && (_log.shouldLog(Log.INFO))) {
    277                         _log.info("More than 100 connections!  " + active + " total: " + _connectionByInboundId.size());
    278                 }
     243       
     244        if ( (_connectionByInboundId.size() > 100) && (_log.shouldLog(Log.INFO)) )
     245            _log.info("More than 100 connections!  " + active
     246                      + " total: " + _connectionByInboundId.size());
     247
    279248        return (active >= _maxConcurrentStreams);
    280249    }
    281250   
    282         public MessageHandler getMessageHandler() {
    283                 return _messageHandler;
    284         }
    285 
    286         public PacketHandler getPacketHandler() {
    287                 return _packetHandler;
    288         }
    289 
    290         public ConnectionHandler getConnectionHandler() {
    291                 return _connectionHandler;
    292         }
    293 
    294         public I2PSession getSession() {
    295                 return _session;
    296         }
    297 
    298         public PacketQueue getPacketQueue() {
    299                 return _outboundQueue;
    300         }
     251    public MessageHandler getMessageHandler() { return _messageHandler; }
     252    public PacketHandler getPacketHandler() { return _packetHandler; }
     253    public ConnectionHandler getConnectionHandler() { return _connectionHandler; }
     254    public I2PSession getSession() { return _session; }
     255    public PacketQueue getPacketQueue() { return _outboundQueue; }
    301256   
    302257    /**
     
    325280            Object o = _connectionByInboundId.remove(new Long(con.getReceiveStreamId()));
    326281            removed = (o == con);
    327                         if(_log.shouldLog(Log.DEBUG)) {
    328                                 _log.debug("Connection removed? " + removed + " remaining: " + _connectionByInboundId.size() + ": " + con);
    329                         }
    330                         if(!removed && _log.shouldLog(Log.DEBUG)) {
     282            if (_log.shouldLog(Log.DEBUG))
     283                _log.debug("Connection removed? " + removed + " remaining: "
     284                           + _connectionByInboundId.size() + ": " + con);
     285            if (!removed && _log.shouldLog(Log.DEBUG))
    331286                _log.debug("Failed to remove " + con +"\n" + _connectionByInboundId.values());
    332                         }
    333287            _connectionLock.notifyAll();
    334288        }
     
    356310        return ping(peer, timeoutMs, true);
    357311    }
    358 
    359312    public boolean ping(Destination peer, long timeoutMs, boolean blocking) {
    360313        return ping(peer, timeoutMs, blocking, null, null, null);
    361314    }
    362 
    363315    public boolean ping(Destination peer, long timeoutMs, boolean blocking, SessionKey keyToUse, Set tagsToSend, PingNotifier notifier) {
    364316        Long id = new Long(_context.random().nextLong(Packet.MAX_STREAM_ID-1)+1);
     
    384336        if (blocking) {
    385337            synchronized (req) {
    386                                 if(!req.pongReceived()) {
    387                                         try {
    388                                                 req.wait(timeoutMs);
    389                                         } catch(InterruptedException ie) {
    390                                         }
    391                                 }
     338                if (!req.pongReceived())
     339                    try { req.wait(timeoutMs); } catch (InterruptedException ie) {}
    392340            }
    393341           
     
    404352
    405353    interface PingNotifier {
    406 
    407354        public void pingComplete(boolean ok);
    408355    }
    409356   
    410357    private class PingFailed implements SimpleTimer.TimedEvent {
    411 
    412358        private Long _id;
    413359        private PingNotifier _notifier;
    414 
    415360        public PingFailed(Long id, PingNotifier notifier) {
    416361            _id = id;
     
    422367            synchronized (_pendingPings) {
    423368                Object o = _pendingPings.remove(_id);
    424                                 if(o != null) {
     369                if (o != null)
    425370                    removed = true;
    426371            }
    427                         }
    428372            if (removed) {
    429                                 if(_notifier != null) {
     373                if (_notifier != null)
    430374                    _notifier.pingComplete(false);
    431                                 }
    432                                 if(_log.shouldLog(Log.INFO)) {
     375                if (_log.shouldLog(Log.INFO))
    433376                    _log.info("Ping failed");
    434377            }
    435378        }
    436379    }
    437         }
    438380   
    439381    private class PingRequest {
    440 
    441382        private boolean _ponged;
    442383        private Destination _peer;
    443384        private PacketLocal _packet;
    444385        private PingNotifier _notifier;
    445 
    446386        public PingRequest(Destination peer, PacketLocal packet, PingNotifier notifier) {
    447387            _ponged = false;
     
    450390            _notifier = notifier;
    451391        }
    452 
    453392        public void pong() {
    454393            _log.debug("Ping successful");
     
    458397                ConnectionManager.PingRequest.this.notifyAll();
    459398            }
    460                         if(_notifier != null) {
     399            if (_notifier != null)
    461400                _notifier.pingComplete(true);
    462401        }
    463                 }
    464 
    465                 public boolean pongReceived() {
    466                         return _ponged;
    467                 }
     402        public boolean pongReceived() { return _ponged; }
    468403    }
    469404   
     
    473408            req = (PingRequest)_pendingPings.remove(new Long(pingId));
    474409        }
    475                 if(req != null) {
     410        if (req != null)
    476411            req.pong();
    477412    }
    478413}
    479 }
  • apps/streaming/java/src/net/i2p/client/streaming/I2PServerSocketFull.java

    rdd7d993 rb0313bd6  
    11package net.i2p.client.streaming;
    22
    3 import java.net.SocketTimeoutException;
    4 import java.util.logging.Level;
    5 import java.util.logging.Logger;
    63import net.i2p.I2PException;
    74
     
    118 */
    129public class I2PServerSocketFull implements I2PServerSocket {
    13 
    1410    private I2PSocketManagerFull _socketManager;
    1511   
    16         /**
    17          *
    18          * @param mgr
    19          */
    2012    public I2PServerSocketFull(I2PSocketManagerFull mgr) {
    2113        _socketManager = mgr;
    2214    }
    2315   
    24         /**
    25          *
    26          * @return
    27          * @throws net.i2p.I2PException
    28          * @throws SocketTimeoutException
    29          */
    30         public I2PSocket accept() throws I2PException, SocketTimeoutException {
     16    public I2PSocket accept() throws I2PException {
    3117        return _socketManager.receiveSocket();
    3218    }
    3319   
    34         public long getSoTimeout() {
    35                 return _socketManager.getConnectionManager().MgetSoTimeout();
    36         }
     20    public void close() { _socketManager.getConnectionManager().setAllowIncomingConnections(false); }
    3721   
    38         public void setSoTimeout(long x) {
    39                 _socketManager.getConnectionManager().MsetSoTimeout(x);
    40         }
    41         /**
    42          * Close the connection.
    43          */
    44         public void close() {
    45                 _socketManager.getConnectionManager().setAllowIncomingConnections(false);
    46         }
    47 
    48         /**
    49          *
    50          * @return _socketManager
    51          */
    52         public I2PSocketManager getManager() {
    53                 return _socketManager;
    54         }
     22    public I2PSocketManager getManager() { return _socketManager; }
    5523}
  • apps/streaming/java/src/net/i2p/client/streaming/I2PSocketFull.java

    rdd7d993 rb0313bd6  
    1212 */
    1313public class I2PSocketFull implements I2PSocket {
    14 
    1514    private Connection _connection;
    1615    private I2PSocket.SocketErrorListener _listener;
     
    2625    }
    2726   
    28 
    2927    public void close() throws IOException {
    3028        Connection c = _connection;
    31                 if(c == null) {
    32                         return;
    33                 }
     29        if (c == null) return;
    3430        if (c.getIsConnected()) {
    3531            OutputStream out = c.getOutputStream();
     
    4945    }
    5046   
    51         Connection getConnection() {
    52                 return _connection;
    53         }
     47    Connection getConnection() { return _connection; }
    5448   
    5549    public InputStream getInputStream() {
    5650        Connection c = _connection;
    57                 if(c != null) {
     51        if (c != null)
    5852            return c.getInputStream();
    59                 } else {
     53        else
    6054            return null;
    6155    }
    62         }
    6356   
    6457    public I2PSocketOptions getOptions() {
    6558        Connection c = _connection;
    66                 if(c != null) {
     59        if (c != null)
    6760            return c.getOptions();
    68                 } else {
     61        else
    6962            return null;
    7063    }
    71         }
    7264   
    7365    public OutputStream getOutputStream() throws IOException {
    7466        Connection c = _connection;
    75                 if(c != null) {
     67        if (c != null)
    7668            return c.getOutputStream();
    77                 } else {
     69        else
    7870            return null;
    7971    }
    80         }
    8172   
    82         public Destination getPeerDestination() {
    83                 return _remotePeer;
    84         }
     73    public Destination getPeerDestination() { return _remotePeer; }
    8574   
    8675    public long getReadTimeout() {
    8776        I2PSocketOptions opts = getOptions();
    88                 if(opts != null) {
     77        if (opts != null)
    8978            return opts.getReadTimeout();
    90                 } else {
     79        else
    9180            return -1;
    9281    }
    93         }
    9482   
    95         public Destination getThisDestination() {
    96                 return _localPeer;
    97         }
     83    public Destination getThisDestination() { return _localPeer; }
    9884   
    9985    public void setOptions(I2PSocketOptions options) {
    10086        Connection c = _connection;
    101                 if(c == null) {
    102                         return;
    103                 }
    104                 if(options instanceof ConnectionOptions) {
     87        if (c == null) return;
     88       
     89        if (options instanceof ConnectionOptions)
    10590            c.setOptions((ConnectionOptions)options);
    106                 } else {
     91        else
    10792            c.setOptions(new ConnectionOptions(options));
    10893    }
    109         }
    11094   
    11195    public void setReadTimeout(long ms) {
    11296        Connection c = _connection;
    113                 if(c == null) {
    114                         return;
    115                 }
     97        if (c == null) return;
     98       
    11699        c.getInputStream().setReadTimeout((int)ms);
    117100        c.getOptions().setReadTimeout(ms);
     
    134117        _connection = null;
    135118        _listener = null;
    136                 if(c != null) {
     119        if (c != null)
    137120            c.disconnectComplete();
    138121    }
    139         }
    140 
    141122    public String toString() {
    142123        Connection c = _connection;
    143                 if(c == null) {
     124        if (c == null)
    144125            return super.toString();
    145                 } else {
     126        else
    146127            return c.toString();
    147128    }
    148129}
    149 }
  • apps/streaming/java/src/net/i2p/client/streaming/I2PSocketManagerFull.java

    rdd7d993 rb0313bd6  
    22
    33import java.net.NoRouteToHostException;
    4 import java.net.SocketTimeoutException;
    54import java.util.HashSet;
    65import java.util.Iterator;
     
    1413import net.i2p.data.Destination;
    1514import net.i2p.util.Log;
     15
    1616
    1717/**
     
    2424 */
    2525public class I2PSocketManagerFull implements I2PSocketManager {
    26 
    2726    private I2PAppContext _context;
    2827    private Log _log;
     
    3534    private static int __managerId = 0;
    3635    private ConnectionManager _connectionManager;
     36   
    3737    /**
    3838     * How long to wait for the client app to accept() before sending back CLOSE?
     
    4141    private static final long ACCEPT_TIMEOUT_DEFAULT = 5*1000;
    4242   
    43         /**
    44          *
    45          */
    4643    public I2PSocketManagerFull() {
    4744        _context = null;
    4845        _session = null;
    4946    }
    50 
    51         /**
    52          *
    53          * @param context
    54          * @param session
    55          * @param opts
    56          * @param name
    57          */
    5847    public I2PSocketManagerFull(I2PAppContext context, I2PSession session, Properties opts, String name) {
    5948        this();
    6049        init(context, session, opts, name);
    6150    }
     51   
    6252    /** how many streams will we allow at once?  */
    6353    public static final String PROP_MAX_STREAMS = "i2p.streaming.maxConcurrentStreams";
     
    6555    /**
    6656     *
    67          *
    68          * @param context
    69          * @param session
    70          * @param opts
    71          * @param name
    7257     */
    7358    public void init(I2PAppContext context, I2PSession session, Properties opts, String name) {
     
    8166            _maxStreams = Integer.parseInt(num);
    8267        } catch (NumberFormatException nfe) {
    83                         if(_log.shouldLog(Log.WARN)) {
     68            if (_log.shouldLog(Log.WARN))
    8469                _log.warn("Invalid max # of concurrent streams, defaulting to unlimited", nfe);
    85                         }
    8670            _maxStreams = -1;
    8771        }
     
    9377       
    9478        if (_log.shouldLog(Log.INFO)) {
    95                         _log.info("Socket manager created.  \ndefault options: " + _defaultOptions + "\noriginal properties: " + opts);
    96         }
    97     }
    98 
    99         /**
    100          *
    101          * @return
    102          */
    103         public I2PSocketOptions buildOptions() {
    104                 return buildOptions(null);
    105         }
    106 
    107         /**
    108          *
    109          * @param opts
    110          * @return
    111          */
     79            _log.info("Socket manager created.  \ndefault options: " + _defaultOptions
     80                      + "\noriginal properties: " + opts);
     81        }
     82    }
     83
     84    public I2PSocketOptions buildOptions() { return buildOptions(null); }
    11285    public I2PSocketOptions buildOptions(Properties opts) {
    11386        ConnectionOptions curOpts = new ConnectionOptions(_defaultOptions);
     
    11689    }
    11790   
    118         /**
    119          *
    120          * @return
    121          */
    12291    public I2PSession getSession() {
    12392        return _session;
    12493    }
    12594   
    126         /**
    127          *
    128          * @return
    129          */
    13095    public ConnectionManager getConnectionManager() {
    13196        return _connectionManager;
    13297    }
    13398
    134         /**
    135          *
    136          * @return
    137          * @throws net.i2p.I2PException
    138          * @throws java.net.SocketTimeoutException
    139          */
    140         public I2PSocket receiveSocket() throws I2PException, SocketTimeoutException {
     99    public I2PSocket receiveSocket() throws I2PException {
    141100        verifySession();
    142                 Connection con = _connectionManager.getConnectionHandler().accept(_connectionManager.MgetSoTimeout());
    143                 if(_log.shouldLog(Log.DEBUG)) {
     101        Connection con = _connectionManager.getConnectionHandler().accept(-1);
     102        if (_log.shouldLog(Log.DEBUG))
    144103            _log.debug("receiveSocket() called: " + con);
    145                 }
    146104        if (con != null) {
    147105            I2PSocketFull sock = new I2PSocketFull(con);
     
    149107            return sock;
    150108        } else {
    151                         if(_connectionManager.MgetSoTimeout() == -1) {
    152109            return null;
    153110        }
    154                         throw new SocketTimeoutException("I2PSocket timed out");
    155                 }
    156111    }
    157112   
     
    160115     * the timeout specified, false otherwise.  This call blocks.
    161116     *
    162          *
    163          * @param peer
    164          * @param timeoutMs
    165          * @return
    166117     */
    167118    public boolean ping(Destination peer, long timeoutMs) {
     
    175126     * @param ms milliseconds to wait, maximum
    176127     */
    177         public void setAcceptTimeout(long ms) {
    178                 _acceptTimeout = ms;
    179         }
    180 
    181         /**
    182          *
    183          * @return
    184          */
    185         public long getAcceptTimeout() {
    186                 return _acceptTimeout;
    187         }
    188 
    189         /**
    190          *
    191          * @param options
    192          */
     128    public void setAcceptTimeout(long ms) { _acceptTimeout = ms; }
     129    public long getAcceptTimeout() { return _acceptTimeout; }
     130
    193131    public void setDefaultOptions(I2PSocketOptions options) {
    194132        _defaultOptions = new ConnectionOptions((ConnectionOptions) options);
    195133    }
    196134
    197         /**
    198          *
    199          * @return
    200          */
    201135    public I2PSocketOptions getDefaultOptions() {
    202136        return _defaultOptions;
    203137    }
    204138
    205         /**
    206          *
    207          * @return
    208          */
    209139    public I2PServerSocket getServerSocket() {
    210140        _connectionManager.setAllowIncomingConnections(true);
     
    213143
    214144    private void verifySession() throws I2PException {
    215                 if(!_connectionManager.getSession().isClosed()) {
     145        if (!_connectionManager.getSession().isClosed())
    216146            return;
    217                 }
    218147        _connectionManager.getSession().connect();
    219148    }
     
    231160                             throws I2PException, NoRouteToHostException {
    232161        verifySession();
    233                 if(options == null) {
     162        if (options == null)
    234163            options = _defaultOptions;
    235                 }
    236164        ConnectionOptions opts = null;
    237                 if(options instanceof ConnectionOptions) {
     165        if (options instanceof ConnectionOptions)
    238166            opts = new ConnectionOptions((ConnectionOptions)options);
    239                 } else {
     167        else
    240168            opts = new ConnectionOptions(options);
    241                 }
    242                 if(_log.shouldLog(Log.INFO)) {
    243                         _log.info("Connecting to " + peer.calculateHash().toBase64().substring(0, 6) + " with options: " + opts);
    244                 }
     169       
     170        if (_log.shouldLog(Log.INFO))
     171            _log.info("Connecting to " + peer.calculateHash().toBase64().substring(0,6)
     172                      + " with options: " + opts);
    245173        Connection con = _connectionManager.connect(peer, opts);
    246                 if(con == null) {
     174        if (con == null)
    247175            throw new TooManyStreamsException("Too many streams (max " + _maxStreams + ")");
    248                 }
    249176        I2PSocketFull socket = new I2PSocketFull(con);
    250177        con.setSocket(socket);
     
    261188     * @param peer Destination to connect to
    262189     *
    263          * @return
    264190     * @throws NoRouteToHostException if the peer is not found or not reachable
    265191     * @throws I2PException if there is some other I2P-related problem
     
    291217     * Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
    292218     *
    293          *
    294          * @return
    295219     */
    296220    public Set listSockets() {
     
    299223        for (Iterator iter = connections.iterator(); iter.hasNext(); ) {
    300224            Connection con = (Connection)iter.next();
    301                         if(con.getSocket() != null) {
     225            if (con.getSocket() != null)
    302226                rv.add(con.getSocket());
    303227        }
    304                 }
    305228        return rv;
    306229    }
    307230
    308         /**
    309          *
    310          * @return
    311          */
    312         public String getName() {
    313                 return _name;
    314         }
    315    
    316         /**
    317          *
    318          * @param name
    319          */
    320         public void setName(String name) {
    321                 _name = name;
    322         }
    323    
    324         /**
    325          *
    326          * @param lsnr
    327          */
     231    public String getName() { return _name; }
     232    public void setName(String name) { _name = name; }
     233   
     234   
    328235    public void addDisconnectListener(I2PSocketManager.DisconnectListener lsnr) {
    329236        _connectionManager.getMessageHandler().addDisconnectListener(lsnr);
    330237    }
    331 
    332         /**
    333          *
    334          * @param lsnr
    335          */
    336238    public void removeDisconnectListener(I2PSocketManager.DisconnectListener lsnr) {
    337239        _connectionManager.getMessageHandler().removeDisconnectListener(lsnr);
  • apps/streaming/java/src/net/i2p/client/streaming/RetransmissionTimer.java

    rdd7d993 rb0313bd6  
    66 *
    77 */
    8 public class RetransmissionTimer extends SimpleTimer {
     8class RetransmissionTimer extends SimpleTimer {
    99    private static final RetransmissionTimer _instance = new RetransmissionTimer();
    1010    public static final SimpleTimer getInstance() { return _instance; }
  • core/java/src/net/i2p/util/Executor.java

    rdd7d993 rb0313bd6  
    66
    77class Executor implements Runnable {
    8 
    98    private I2PAppContext _context;
    109    private Log _log;
    1110    private List _readyEvents;
    12         private SimpleStore runn;
    13 
    14         public Executor(I2PAppContext ctx, Log log, List events, SimpleStore x) {
     11    public Executor(I2PAppContext ctx, Log log, List events) {
    1512        _context = ctx;
    1613        _readyEvents = events;
    17                 runn = x;
    1814    }
    19 
    2015    public void run() {
    21                 while(runn.getAnswer()) {
     16        while (true) {
    2217            SimpleTimer.TimedEvent evt = null;
    2318            synchronized (_readyEvents) {
    24                                 if(_readyEvents.size() <= 0) {
    25                                         try {
    26                                                 _readyEvents.wait();
    27                                         } catch(InterruptedException ie) {
    28                                         }
    29                                 }
    30                                 if(_readyEvents.size() > 0) {
     19                if (_readyEvents.size() <= 0)
     20                    try { _readyEvents.wait(); } catch (InterruptedException ie) {}
     21                if (_readyEvents.size() > 0)
    3122                    evt = (SimpleTimer.TimedEvent)_readyEvents.remove(0);
    3223            }
    33                         }
    3424
    3525            if (evt != null) {
     
    4131                }
    4232                long time = _context.clock().now() - before;
    43                                 if((time > 1000) && (_log != null) && (_log.shouldLog(Log.WARN))) {
     33                if ( (time > 1000) && (_log != null) && (_log.shouldLog(Log.WARN)) )
    4434                    _log.warn("wtf, event execution took " + time + ": " + evt);
    4535            }
    4636        }
    4737    }
    48         }
    4938   
    50         /**
    51          *
    52          * @param msg
    53          * @param t
    54          */
    5539    private void log(String msg, Throwable t) {
    5640        synchronized (this) {
    57                         if(_log == null) {
     41            if (_log == null)
    5842                _log = I2PAppContext.getGlobalContext().logManager().getLog(SimpleTimer.class);
    5943        }
    60                 }
    6144        _log.log(Log.CRIT, msg, t);
    6245    }
  • core/java/src/net/i2p/util/SimpleTimer.java

    rdd7d993 rb0313bd6  
    1717 */
    1818public class SimpleTimer {
    19 
    2019    private static final SimpleTimer _instance = new SimpleTimer();
    21 
    22         public static SimpleTimer getInstance() {
    23                 return _instance;
    24         }
     20    public static SimpleTimer getInstance() { return _instance; }
    2521    private I2PAppContext _context;
    2622    private Log _log;
     
    3026    private Map _eventTimes;
    3127    private List _readyEvents;
    32         private SimpleStore runn;
    33 
    34         /**
    35          *
    36          */
    37         protected SimpleTimer() {
    38                 this("SimpleTimer");
    39         }
    40    
    41         /**
    42          *
    43          * @param name
    44          */
     28   
     29    protected SimpleTimer() { this("SimpleTimer"); }
    4530    protected SimpleTimer(String name) {
    46                 runn = new SimpleStore(true);
    4731        _context = I2PAppContext.getGlobalContext();
    4832        _log = _context.logManager().getLog(SimpleTimer.class);
     
    5539        runner.start();
    5640        for (int i = 0; i < 3; i++) {
    57                         I2PThread executor = new I2PThread(new Executor(_context, _log, _readyEvents, runn));
     41            I2PThread executor = new I2PThread(new Executor(_context, _log, _readyEvents));
    5842            executor.setName(name + "Executor " + i);
    5943            executor.setDaemon(true);
     
    6246    }
    6347   
    64         /**
    65          * Removes the SimpleTimer.
    66          */
    67         public void removeSimpleTimer() {
    68                 synchronized(_events) {
    69                         runn.setAnswer(false);
    70                         _events.notifyAll();
    71                 }
    72         }
    73 
    74         /**
    75          *
    76          * @param event
    77          * @param timeoutMs
    78          */
    7948    public void reschedule(TimedEvent event, long timeoutMs) {
    8049        addEvent(event, timeoutMs, false);
     
    8756     * timeout.  If this is not the desired behavior, call removeEvent first.
    8857     *
    89          * @param event
    90          * @param timeoutMs
    9158     */
    92         public void addEvent(TimedEvent event, long timeoutMs) {
    93                 addEvent(event, timeoutMs, true);
    94         }
    95 
     59    public void addEvent(TimedEvent event, long timeoutMs) { addEvent(event, timeoutMs, true); }
    9660    /**
    97          * @param event
    98          * @param timeoutMs
    9961     * @param useEarliestTime if its already scheduled, use the earlier of the
    10062     *                        two timeouts, else use the later
     
    12587                }
    12688            }
    127                         while(_events.containsKey(time)) {
     89            while (_events.containsKey(time))
    12890                time = new Long(time.longValue() + 1);
    129                         }
    13091            _events.put(time, event);
    13192            _eventTimes.put(event, time);
     
    147108        }
    148109        if (time.longValue() > eventTime + 100) {
    149                         if(_log.shouldLog(Log.WARN)) {
    150                                 _log.warn("Lots of timer congestion, had to push " + event + " back " + (time.longValue() - eventTime) + "ms (# events: " + totalEvents + ")");
    151                         }
     110            if (_log.shouldLog(Log.WARN))
     111                _log.warn("Lots of timer congestion, had to push " + event + " back "
     112                           + (time.longValue()-eventTime) + "ms (# events: " + totalEvents + ")");
    152113        }
    153114        long timeToAdd = System.currentTimeMillis() - now;
    154115        if (timeToAdd > 50) {
    155                         if(_log.shouldLog(Log.WARN)) {
     116            if (_log.shouldLog(Log.WARN))
    156117                _log.warn("timer contention: took " + timeToAdd + "ms to add a job with " + totalEvents + " queued");
    157118        }
    158                 }
    159119           
    160120    }
    161121   
    162         /**
    163          *
    164          * @param evt
    165          * @return
    166          */
    167122    public boolean removeEvent(TimedEvent evt) {
    168                 if(evt == null) {
    169                         return false;
    170                 }
     123        if (evt == null) return false;
    171124        synchronized (_events) {
    172125            Long when = (Long)_eventTimes.remove(evt);
    173                         if(when != null) {
     126            if (when != null)
    174127                _events.remove(when);
    175                         }
    176128            return null != when;
    177129        }
     
    182134     */
    183135    public interface TimedEvent {
    184 
    185136        /**
    186137         * the time requested has been reached (this call should NOT block,
     
    190141        public void timeReached();
    191142    }
     143   
    192144    private long _occurredTime;
    193145    private long _occurredEventCount;
    194         // not used
    195         //  private TimedEvent _recentEvents[] = new TimedEvent[5];
     146    private TimedEvent _recentEvents[] = new TimedEvent[5];
     147   
    196148    private class SimpleTimerRunner implements Runnable {
    197 
    198149        public void run() {
    199150            List eventsToFire = new ArrayList(1);
    200                         while(runn.getAnswer()) {
     151            while (true) {
    201152                try {
    202153                    synchronized (_events) {
     
    208159                        long nextEventDelay = -1;
    209160                        Object nextEvent = null;
    210                                                 while(runn.getAnswer()) {
    211                                                         if(_events.size() <= 0) {
    212                                                                 break;
    213                                                         }
     161                        while (true) {
     162                            if (_events.size() <= 0) break;
    214163                            Long when = (Long)_events.firstKey();
    215164                            if (when.longValue() <= now) {
     
    227176                        if (eventsToFire.size() <= 0) {
    228177                            if (nextEventDelay != -1) {
    229                                                                 if(_log.shouldLog(Log.DEBUG)) {
     178                                if (_log.shouldLog(Log.DEBUG))
    230179                                    _log.debug("Next event in " + nextEventDelay + ": " + nextEvent);
    231                                                                 }
    232180                                _events.wait(nextEventDelay);
    233181                            } else {
     
    236184                        }
    237185                    }
     186                } catch (ThreadDeath td) {
     187                    return; // die
    238188                } catch (InterruptedException ie) {
    239189                    // ignore
     
    251201
    252202                synchronized (_readyEvents) {
    253                                         for(int i = 0; i < eventsToFire.size(); i++) {
     203                    for (int i = 0; i < eventsToFire.size(); i++)
    254204                        _readyEvents.add(eventsToFire.get(i));
    255                                         }
    256205                    _readyEvents.notifyAll();
    257206                }
Note: See TracChangeset for help on using the changeset viewer.