/** * This is periodically called by the JICPMediatorManager and is used by this NIOMediator to * evaluate the elapsed time without the need of a dedicated thread or timer. */ public final void tick(long currentTime) { if (active && !connectionDropped) { // 1) If there is a blocking read operation in place check the // response timeout inpManager.checkResponseTime(currentTime); // 2) Evaluate the keep alive if (keepAliveTime > 0) { if ((currentTime - lastReceivedTime) > (keepAliveTime + RESPONSE_TIMEOUT)) { // Missing keep-alive. // The OUT connection is no longer valid if (outManager.isConnected()) { myLogger.log(Logger.WARNING, myID + ": Missing keep-alive"); outManager.resetConnection(); } // Check the INP connection. Since this method must return // asap, does it in a separated Thread if (inpManager.isConnected()) { Thread t = new Thread() { public void run() { try { // JICPPacket pkt = new JICPPacket(JICPProtocol.KEEP_ALIVE_TYPE, // JICPProtocol.DEFAULT_INFO, null); // inpManager.dispatch(pkt, false); inpManager.sendServerKeepAlive(); if (myLogger.isLoggable(Logger.CONFIG)) { myLogger.log(Logger.CONFIG, myID + ": IC valid"); } } catch (Exception e) { // Just do nothing: the INP connection has been reset } } }; t.start(); } } } // 3) Evaluate the max disconnection time if (outManager.checkMaxDisconnectionTime(currentTime)) { myLogger.log(Logger.SEVERE, myID + ": Max disconnection time expired."); // Consider as if the FrontEnd has terminated spontaneously --> // Kill the above container (this will also kill this NIOBEDispatcher). kill(); } } }
/** Handle a connection DROP_DOWN request from the FE. */ protected void handleDropDown(Connection c, JICPPacket pkt, InetAddress addr, int port) { if (myLogger.isLoggable(Logger.INFO)) { myLogger.log(Logger.INFO, myID + ": DROP_DOWN request received."); } try { // If the INP connection is down or we have some postponed command // to flush, refuse dropping the connection if (inpManager.isConnected() && inpManager.isEmpty()) { JICPPacket rsp = new JICPPacket(JICPProtocol.RESPONSE_TYPE, JICPProtocol.DEFAULT_INFO, null); c.writePacket(rsp); inpManager.resetConnection(); outManager.resetConnection(); connectionDropped = true; } else { myLogger.log(Logger.WARNING, myID + ": DROP_DOWN request refused."); JICPPacket rsp = new JICPPacket(JICPProtocol.ERROR_TYPE, getReconnectInfo(), null); c.writePacket(rsp); } } catch (Exception e) { myLogger.log(Logger.WARNING, myID + ": Error writing DROP_DOWN response. " + e); } }
/** * Notify this NIOMediator that an error occurred on one of the Connections it was using. This * information is important since, unlike normal mediators, a NIOMediator typically does not read * packets from connections on its own (the JICPMediatorManager does that in general). */ public void handleConnectionError(Connection c, Exception e) { myLogger.log(Level.WARNING, "connection error", e); if (active && peerActive) { // Try assuming it is the input connection try { inpManager.checkConnection(c); myLogger.log(Logger.WARNING, myID + ": IC Disconnection detected"); inpManager.resetConnection(); } catch (ICPException icpe) { // Then try assuming it is the output connection try { outManager.checkConnection(c); myLogger.log(Logger.WARNING, myID + ": OC Disconnection detected"); outManager.resetConnection(); } catch (ICPException icpe2) { // Ignore it } } } }
/** * Overloaded version of the handleJICPPacket() method including the <code>Connection</code> the * incoming JICPPacket was received from. This information is important since, unlike normal * mediators, a NIOMediator may not read packets from connections on its own (the * JICPMediatorManager does that in general). */ public JICPPacket handleJICPPacket(Connection c, JICPPacket pkt, InetAddress addr, int port) throws ICPException { if (pkt.getType() == JICPProtocol.DROP_DOWN_TYPE) { // Note that the return packet is written inside the handleDropDown() // method since the connection must be closed after the response has // been sent back. handleDropDown(c, pkt, addr, port); return null; } checkTerminatedInfo(pkt); // Update keep-alive info lastReceivedTime = System.currentTimeMillis(); byte type = pkt.getType(); if (type == JICPProtocol.COMMAND_TYPE) { if (peerActive) { return outManager.handleCommand(c, pkt); } else { // The remote FrontEnd has terminated spontaneously --> // Kill the above container (this will also kill this NIOBEDispatcher). kill(); return null; } } else if (type == JICPProtocol.KEEP_ALIVE_TYPE) { if (enableServerKeepAlive) { inpManager.sendServerKeepAlive(); } return outManager.handleKeepAlive(c, pkt); } /* Asynch-reply else if (type == JICPProtocol.RESPONSE_TYPE || type == JICPProtocol.ERROR_TYPE) { inpManager.handleResponse(c, pkt); return null; }*/ else { throw new ICPException("Unexpected packet type " + type); } }
/** Make this NIOBEDispatcher terminate. */ public void shutdown() { active = false; if (myLogger.isLoggable(Logger.INFO)) { myLogger.log(Logger.INFO, myID + ": shutting down"); } // Deregister from the JICPServer if (myID != null) { myMediatorManager.deregisterMediator(myID); } inpManager.shutdown(); outManager.shutdown(); }
public void evalParserOutput(final UnlabeledBracketSetCorpus output, final OutputManager man) throws CorpusError, EvalError, IOException { final ChunkedCorpus chunked = CorpusUtil.getChunkedCorpusClumps(alpha, output); treebankEval.getExperiment("asTrees", output.getTrees()).writeSummary(man.getResultsStream()); clumpsEval.addExperiment(clumpsEval.newChunkingExperiment("clumps", chunked)); clumpsEval.writeSummary(evalReportType, man.getResultsStream(), false); ubsFromClumpsEval.getExperiment("", output.getTrees()).writeSummary(man.getResultsStream()); npsEval.addExperiment(npsEval.newChunkingExperiment("NPs", chunked)); npsEval.writeSummary(evalReportType, man.getResultsStream(), false); ubsFromNPsEval.getExperiment("", output.getTrees()).writeSummary(man.getResultsStream()); ubsFromPPsEval.getExperiment("", output.getTrees()).writeSummary(man.getResultsStream()); if (!man.isNull()) { BufferedWriter bw = Util.bufferedWriter(man.treeOutputFilename()); output.writeTo(bw, outputText); bw = Util.bufferedWriter(man.clumpsOutputFilename()); chunked.writeTo(bw, outputText); } }
/** * Passes to this JICPMediator the connection opened by the mediated entity. This is called by the * JICPMediatorManager this Mediator is attached to as soon as the mediated entity (re)connects. * * @param c the connection to the mediated entity * @param pkt the packet that was sent by the mediated entity when opening this connection * @param addr the address of the mediated entity * @param port the local port used by the mediated entity * @return an indication to the JICPMediatorManager to keep the connection open. */ public boolean handleIncomingConnection( Connection c, JICPPacket pkt, InetAddress addr, int port) { checkTerminatedInfo(pkt); if (peerActive) { if (connectionDropped) { droppedToDisconnected(); } // Update keep-alive info lastReceivedTime = System.currentTimeMillis(); boolean inp = false; byte[] data = pkt.getData(); if (data.length == 1) { inp = (data[0] == 1); } if (inp) { inpManager.setConnection((NIOJICPConnection) c); if (myLogger.isLoggable(Logger.CONFIG)) { myLogger.log(Logger.CONFIG, myID + ": New INP Connection establishd"); } } else { outManager.setConnection(c); if (myLogger.isLoggable(Logger.CONFIG)) { myLogger.log(Logger.CONFIG, myID + ": New OUT Connection establishd"); } } return true; } else { // The remote FrontEnd has terminated spontaneously --> // Kill the above container (this will also kill this NIOBEDispatcher). kill(); return false; } }
public boolean isConnected() { return inpManager.isConnected() && outManager.isConnected(); }
/** * Move from the connectionDropped state to the Disconnected state. This may happen when - a * packet must be dispatched to the FE. - an incoming connection is detected */ private void droppedToDisconnected() { connectionDropped = false; outManager.setExpirationDeadline(); }