public static void shutdown() { logger_.info("Shutting down ..."); synchronized (MessagingService.class) { /* Stop listening on any socket */ for (SelectionKey skey : listenSockets_.values()) { SelectorManager.getSelectorManager().cancel(skey); } listenSockets_.clear(); /* Shutdown the threads in the EventQueue's */ messageDeserializationExecutor_.shutdownNow(); messageSerializerExecutor_.shutdownNow(); messageDeserializerExecutor_.shutdownNow(); streamExecutor_.shutdownNow(); /* shut down the cachetables */ taskCompletionMap_.shutdown(); callbackMap_.shutdown(); /* Interrupt the selector manager thread */ SelectorManager.getSelectorManager().interrupt(); poolTable_.clear(); verbHandlers_.clear(); bShutdown_ = true; } logger_.debug("Shutdown invocation complete."); }
protected MessagingService() { for (ReservedVerbs_ verbs : ReservedVerbs_.values()) { reservedVerbs_.put(verbs.toString(), verbs.toString()); } verbHandlers_ = new HashMap<String, IVerbHandler>(); endPoints_ = new HashSet<EndPoint>(); /* * Leave callbacks in the cachetable long enough that any related messages will arrive * before the callback is evicted from the table. The concurrency level is set at 128 * which is the sum of the threads in the pool that adds shit into the table and the * pool that retrives the callback from here. */ int maxSize = MessagingConfig.getMessagingThreadCount(); callbackMap_ = new Cachetable<String, IAsyncCallback>(2 * DatabaseDescriptor.getRpcTimeout()); taskCompletionMap_ = new Cachetable<String, IAsyncResult>(2 * DatabaseDescriptor.getRpcTimeout()); messageDeserializationExecutor_ = new DebuggableThreadPoolExecutor( maxSize, maxSize, Integer.MAX_VALUE, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactoryImpl("MESSAGING-SERVICE-POOL")); messageSerializerExecutor_ = new DebuggableThreadPoolExecutor( maxSize, maxSize, Integer.MAX_VALUE, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactoryImpl("MESSAGE-SERIALIZER-POOL")); messageDeserializerExecutor_ = new DebuggableThreadPoolExecutor( maxSize, maxSize, Integer.MAX_VALUE, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactoryImpl("MESSAGE-DESERIALIZER-POOL")); streamExecutor_ = new DebuggableThreadPoolExecutor( 1, 1, Integer.MAX_VALUE, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadFactoryImpl("MESSAGE-STREAMING-POOL")); protocol_ = hash(HashingSchemes.MD5, "FB-MESSAGING".getBytes()); /* register the response verb handler */ registerVerbHandlers(MessagingService.responseVerbHandler_, new ResponseVerbHandler()); /* register stage for response */ StageManager.registerStage( MessagingService.responseStage_, new MultiThreadedStage("RESPONSE-STAGE", maxSize)); }
public void deregisterAllVerbHandlers(EndPoint localEndPoint) { Iterator keys = verbHandlers_.keySet().iterator(); String key = null; /* * endpoint specific verbhandlers can be distinguished because * their key's contain the name of the endpoint. */ while (keys.hasNext()) { key = (String) keys.next(); if (key.contains(localEndPoint.toString())) keys.remove(); } }
public static TcpConnectionManager getConnectionPool(EndPoint from, EndPoint to) { String key = from + ":" + to; TcpConnectionManager cp = poolTable_.get(key); if (cp == null) { lock_.lock(); try { cp = poolTable_.get(key); if (cp == null) { cp = new TcpConnectionManager( MessagingConfig.getConnectionPoolInitialSize(), MessagingConfig.getConnectionPoolGrowthFactor(), MessagingConfig.getConnectionPoolMaxSize(), from, to); poolTable_.put(key, cp); } } finally { lock_.unlock(); } } return cp; }
public static ConnectionStatistics[] getPoolStatistics() { Set<ConnectionStatistics> stats = new HashSet<ConnectionStatistics>(); Iterator<TcpConnectionManager> it = poolTable_.values().iterator(); while (it.hasNext()) { TcpConnectionManager cp = it.next(); ConnectionStatistics cs = new ConnectionStatistics( cp.getLocalEndPoint(), cp.getRemoteEndPoint(), cp.getPoolSize(), cp.getConnectionsInUse()); stats.add(cs); } return stats.toArray(new ConnectionStatistics[0]); }
public void listen(EndPoint localEp, boolean isHttp) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(); ServerSocket ss = serverChannel.socket(); ss.bind(localEp.getInetAddress()); serverChannel.configureBlocking(false); SelectionKeyHandler handler = null; if (isHttp) { handler = new HttpConnectionHandler(); } else { handler = new TcpConnectionHandler(localEp); } SelectionKey key = SelectorManager.getSelectorManager() .register(serverChannel, handler, SelectionKey.OP_ACCEPT); endPoints_.add(localEp); listenSockets_.put(localEp, key); }
public IVerbHandler getVerbHandler(String type) { IVerbHandler handler = (IVerbHandler) verbHandlers_.get(type); return handler; }
public void deregisterVerbHandlers(String type) { verbHandlers_.remove(type); }
public void registerVerbHandlers(String type, IVerbHandler verbHandler) { checkForReservedVerb(type); verbHandlers_.put(type, verbHandler); }
private void checkForReservedVerb(String type) { if (reservedVerbs_.get(type) != null && verbHandlers_.get(type) != null) { throw new IllegalArgumentException(type + " is a reserved verb handler. Scram!"); } }