private void x_startTorrent() {
boolean ok = _util.connect();
if (!ok) fatal("Unable to connect to I2P");
if (coordinator == null) {
I2PServerSocket serversocket = _util.getServerSocket();
if (serversocket == null) fatal("Unable to listen for I2P connections");
else {
Destination d = serversocket.getManager().getSession().getMyDestination();
if (_log.shouldLog(Log.INFO))
_log.info(
"Listening on I2P destination "
+ d.toBase64()
+ " / "
+ d.calculateHash().toBase64());
}
if (_log.shouldLog(Log.INFO))
_log.info("Starting PeerCoordinator, ConnectionAcceptor, and TrackerClient");
activity = "Collecting pieces";
coordinator = new PeerCoordinator(_util, id, infoHash, meta, storage, this, this);
coordinator.setUploaded(savedUploaded);
if (_peerCoordinatorSet != null) {
// multitorrent
_peerCoordinatorSet.add(coordinator);
} else {
// single torrent
acceptor = new ConnectionAcceptor(_util, new PeerAcceptor(coordinator));
}
// TODO pass saved closest DHT nodes to the tracker? or direct to the coordinator?
trackerclient = new TrackerClient(_util, meta, additionalTrackerURL, coordinator, this);
}
// ensure acceptor is running when in multitorrent
if (_peerCoordinatorSet != null && acceptor != null) {
acceptor.startAccepting();
}
stopped = false;
if (coordinator.halted()) {
coordinator.restart();
if (_peerCoordinatorSet != null) _peerCoordinatorSet.add(coordinator);
}
if (!trackerclient.started()) {
trackerclient.start();
} else if (trackerclient.halted()) {
if (storage != null) {
try {
storage.reopen();
} catch (IOException ioe) {
try {
storage.close();
} catch (IOException ioee) {
ioee.printStackTrace();
}
fatal("Could not reopen storage", ioe);
}
}
trackerclient.start();
} else {
if (_log.shouldLog(Log.INFO)) _log.info("NOT starting TrackerClient???");
}
}
@Override
public void setUp() throws Exception {
routedConnectionFactory =
LimeTestUtils.createInjector().getInstance(RoutedConnectionFactory.class);
ACCEPTOR = new ConnectionAcceptor();
ACCEPTOR.start();
ConnectionSettings.ALLOW_WHILE_DISCONNECTED.setValue(true);
ConnectionSettings.PREFERENCING_ACTIVE.setValue(false);
}
public void testNonBlockingBadHandshake() throws Exception {
ACCEPTOR.getObserver().setBadHandshake(true);
RoutedConnection rc =
routedConnectionFactory.createRoutedConnection("127.0.0.1", LISTEN_PORT, ConnectType.PLAIN);
StubGnetConnectObserver observer = new StubGnetConnectObserver();
rc.initialize(observer);
observer.waitForResponse(10000);
assertFalse(observer.isShutdown());
assertTrue(observer.isBadHandshake());
assertFalse(observer.isConnect());
assertFalse(observer.isNoGOK());
}
public void delegate(final String word, final Socket sock, boolean newThread) {
boolean localHost = NetworkUtils.isLocalHost(sock);
boolean drop = false;
if (localOnly && !localHost) drop = true;
if (!localOnly && localHost && ConnectionSettings.LOCAL_IS_PRIVATE.getValue()) drop = true;
if (drop) {
IOUtils.close(sock);
return;
}
if (blocking && newThread) {
Runnable r =
new Runnable() {
public void run() {
acceptor.acceptConnection(word, sock);
}
};
ThreadFactory.startThread(r, "IncomingConnection");
} else acceptor.acceptConnection(word, sock);
}
/**
* Main operation of the Reactor:
*
* <UL>
* <LI>Uses the <CODE>Selector.select()</CODE> method to find new requests from clients
* <LI>For each request in the selection set:
* <UL>
* If it is <B>acceptable</B>, use the ConnectionAcceptor to accept it, create a new
* ConnectionHandler for it register it to the Selector
* <LI>If it is <B>readable</B>, use the ConnectionHandler to read it, extract messages
* and insert them to the ThreadPool
* </UL>
*/
public void run() {
// Create & start the ThreadPool
ExecutorService executor = Executors.newFixedThreadPool(_poolSize);
Selector selector = null;
ServerSocketChannel ssChannel = null;
try {
selector = Selector.open();
ssChannel = createServerSocket(_port);
} catch (IOException e) {
logger.info("cannot create the selector -- server socket is busy?");
return;
}
_data = new ReactorData<T>(executor, selector, _protocolFactory, _tokenizerFactory);
ConnectionAcceptor<T> connectionAcceptor = new ConnectionAcceptor<T>(ssChannel, _data);
// Bind the server socket channel to the selector, with the new
// acceptor as attachment
try {
ssChannel.register(selector, SelectionKey.OP_ACCEPT, connectionAcceptor);
} catch (ClosedChannelException e) {
logger.info("server channel seems to be closed!");
return;
}
while (_shouldRun && selector.isOpen()) {
// Wait for an event
try {
selector.select();
} catch (IOException e) {
logger.info("trouble with selector: " + e.getMessage());
continue;
}
// Get list of selection keys with pending events
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
// Process each key
while (it.hasNext()) {
// Get the selection key
SelectionKey selKey = (SelectionKey) it.next();
// Remove it from the list to indicate that it is being
// processed. it.remove removes the last item returned by next.
it.remove();
// Check if it's a connection request
if (selKey.isValid() && selKey.isAcceptable()) {
logger.info("Accepting a connection");
ConnectionAcceptor<T> acceptor = (ConnectionAcceptor<T>) selKey.attachment();
try {
acceptor.accept();
} catch (IOException e) {
logger.info("problem accepting a new connection: " + e.getMessage());
}
continue;
}
// Check if a message has been sent
if (selKey.isValid() && selKey.isReadable()) {
ConnectionHandler<T> handler = (ConnectionHandler<T>) selKey.attachment();
logger.info("Channel is ready for reading");
handler.read();
}
// Check if there are messages to send
if (selKey.isValid() && selKey.isWritable()) {
ConnectionHandler<T> handler = (ConnectionHandler<T>) selKey.attachment();
logger.info("Channel is ready for writing");
handler.write();
}
}
}
stopReactor();
}
@Override
public void tearDown() throws Exception {
ACCEPTOR.shutdown();
Thread.sleep(1000);
}
/**
* @return true if restarted
* @since 0.8.4
*/
public boolean restartAcceptor() {
if (acceptor == null) return false;
acceptor.restart();
return true;
}
