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."); }
private synchronized String allocName(String type, String namePattern) { Map<String, Integer> patterns = nameTypes.get(type); if (patterns == null) { patterns = new HashMap<String, Integer>(); nameTypes.put(type, patterns); } Integer id = patterns.get(namePattern); if (id == null) id = 0; id++; patterns.put(namePattern, id); String agentName = namePattern.replaceFirst("#", id.toString()); if (agentName.equals(namePattern)) Log.warn("AllocName: missing '#' in name pattern '" + namePattern + "'"); else Log.debug( "AllocName: for type=" + type + " assigned '" + agentName + "' from pattern '" + namePattern + "'"); return agentName; }
/** * Retrieves information about the set of alerts that this generator may produce. The map returned * should be between the notification type for a particular notification and the human-readable * description for that notification. This alert generator must not generate any alerts with types * that are not contained in this list. * * @return Information about the set of alerts that this generator may produce. */ @Override public Map<String, String> getAlerts() { Map<String, String> alerts = new LinkedHashMap<>(); alerts.put( ALERT_TYPE_LDAP_CONNECTION_HANDLER_CONSECUTIVE_FAILURES, ALERT_DESCRIPTION_LDAP_CONNECTION_HANDLER_CONSECUTIVE_FAILURES); alerts.put( ALERT_TYPE_LDAP_CONNECTION_HANDLER_UNCAUGHT_ERROR, ALERT_DESCRIPTION_LDAP_CONNECTION_HANDLER_UNCAUGHT_ERROR); return alerts; }
static Set<RDPConnection> getAllConnections() { lock.lock(); try { Set<RDPConnection> allCon = new HashSet<RDPConnection>(); Iterator<Map<ConnectionInfo, RDPConnection>> iter = allConMap.values().iterator(); while (iter.hasNext()) { Map<ConnectionInfo, RDPConnection> dcMap = iter.next(); allCon.addAll(dcMap.values()); } return allCon; } finally { lock.unlock(); } }
/** * returns the RDPConnection that is registered for the given datagram channel and is connected to * the host/port in ConnectionInfo returns null if there is no matching registered rdpconnection */ static RDPConnection getConnection(DatagramChannel dc, ConnectionInfo conInfo) { lock.lock(); try { Map<ConnectionInfo, RDPConnection> dcConMap = allConMap.get(dc); if (dcConMap == null) { // there isnt even a datagram associated if (Log.loggingNet) Log.net("RDPServer.getConnection: could not find datagram"); return null; } return dcConMap.get(conInfo); } finally { lock.unlock(); } }
/** * Helper function to get value from map. * * @param map Map to take value from. * @param key Key to search in map. * @param ifNull Default value if {@code null} was returned by map. * @param <K> Key type. * @param <V> Value type. * @return Value from map or default value if map return {@code null}. */ public static <K, V> V getOrElse(Map<K, V> map, K key, V ifNull) { assert map != null; V res = map.get(key); return res != null ? res : ifNull; }
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)); }
/** * removes this connection from the connections map the datagram channel still sticks around in * case it needs to be reused */ static void removeConnection(RDPConnection con) { lock.lock(); try { if (Log.loggingNet) Log.net("RDPServer.removeConnection: removing con " + con); con.setState(RDPConnection.CLOSED); DatagramChannel dc = con.getDatagramChannel(); // first we get the set of connections attached to the given dc Map<ConnectionInfo, RDPConnection> dcConMap = allConMap.get(dc); if (dcConMap == null) { throw new MVRuntimeException("RDPServer.removeConnection: cannot find dc"); } int localPort = con.getLocalPort(); int remotePort = con.getRemotePort(); InetAddress remoteAddr = con.getRemoteAddr(); ConnectionInfo conInfo = new ConnectionInfo(remoteAddr, remotePort, localPort); Object rv = dcConMap.remove(conInfo); if (rv == null) { throw new MVRuntimeException("RDPServer.removeConnection: could not find the connection"); } // close the datagramchannel if needed // conditions: no other connections on this datagramchannel // no socket listening on this datagramchannel if (dcConMap.isEmpty()) { Log.net("RDPServer.removeConnection: no other connections for this datagramchannel (port)"); // there are no more connections on this datagram channel // check if there is a serversocket listening if (getRDPSocket(dc) == null) { Log.net("RDPServer.removeConnection: no socket listening on this port - closing"); // no socket either, close the datagramchannel dc.socket().close(); channelMap.remove(localPort); Log.net("RDPServer.removeConnection: closed and removed datagramchannel/socket"); } else { Log.net("RDPServer.removeConnection: there is a socket listening on this port"); } } else { Log.net("RDPServer.removeConnection: there are other connections on this port"); } } finally { lock.unlock(); } }
public void setAttribute(String name, Object value) { if (name == null) { throw new NullPointerException("null name parameter"); } if (attributes == null) { attributes = getHttpContext().getAttributes(); } attributes.put(name, value); }
protected void registeredClient(SocketChannel sc) throws IOException { ClientInfo ci = new ClientInfo(); ci.channel = sc; ci.outBuf.clear(); ci.outBuf.put(TypeServerConstants.WELCOME); ci.outBuf.flip(); allClients.put(sc, ci); send(sc, ci); }
protected void handleClient(SelectionKey key) throws IOException { SocketChannel sc = (SocketChannel) key.channel(); ClientInfo ci = (ClientInfo) allClients.get(sc); if (ci == null) throw new IllegalStateException("Unknown client"); if (key.isWritable()) send(sc, ci); if (key.isReadable()) // 从一个客户端读进所有的可用数据 recv(sc, ci); }
public Object getAttribute(String name) { if (name == null) { throw new NullPointerException("null name parameter"); } if (attributes == null) { attributes = getHttpContext().getAttributes(); } return attributes.get(name); }
public static String getNickFromSocket(SocketChannel sc) { for (Entry<String, SocketChannel> client : clients.entrySet()) { if (client.getValue().equals(sc)) { return client.getKey(); } } return null; }
public static void kill(StringTokenizer st) { try { if (st.hasMoreTokens()) { String clientName = st.nextToken(); if (clients.containsKey(clientName)) { SocketChannel clientChannel = clients.get(clientName); clients.remove(clientName); sendMessage(clientChannel, MessageUtils.bye()); notifyAllClients(clientName + " leave this chatroom"); System.out.println(clientName + " leave this chatroom"); Utils.tryClose(clientChannel); } else { System.err.println("kill: no such client"); } } else { System.err.println("kill: no client name"); } } catch (Exception expt) { Utils.printErrorAndExit(expt.getMessage()); } }
public static void disconnectClient(SocketChannel sc) { String clientName = getNickFromSocket(sc); if (clientName == null) { Utils.printErrorAndExit("Error: it could not happen"); } sendMessage(sc, MessageUtils.bye()); clients.remove(clientName); Utils.tryClose(sc); notifyAllClients(clientName + " leave this chatroom"); System.out.println(clientName + " leave this chatroom"); }
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(); } }
/** the conn data should already be set (remote addr, etc) */ static void registerConnection(RDPConnection con, DatagramChannel dc) { lock.lock(); try { if (Log.loggingNet) Log.net("RDPServer.registerConnection: registering con " + con); // first we get the set of connections attached to the given dc Map<ConnectionInfo, RDPConnection> dcConMap = allConMap.get(dc); if (dcConMap == null) { dcConMap = new HashMap<ConnectionInfo, RDPConnection>(); } // add this connection to the map int localPort = con.getLocalPort(); int remotePort = con.getRemotePort(); InetAddress remoteAddr = con.getRemoteAddr(); ConnectionInfo conInfo = new ConnectionInfo(remoteAddr, remotePort, localPort); dcConMap.put(conInfo, con); allConMap.put(dc, dcConMap); } finally { lock.unlock(); } }
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 void stop() { try { if (port[0] != -1) { for (Entry<String, SocketChannel> client : clients.entrySet()) { if (client.getValue().isConnected()) { sendMessage(client.getValue(), MessageUtils.bye()); Utils.tryClose(client.getValue()); } } Utils.tryClose(serverSocket); clients.clear(); port[0] = -1; } else { System.err.println("stop: already stopped"); } } catch (Exception expt) { Utils.printErrorAndExit(expt.getMessage()); } }
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); }
/** * Sets configuration properties from the map. * * @param endpointCfg Map of properties. * @throws IgniteCheckedException If invalid property name or value. */ public void setupConfiguration(Map<String, String> endpointCfg) throws IgniteCheckedException { for (Map.Entry<String, String> e : endpointCfg.entrySet()) { try { switch (e.getKey()) { case "type": case "host": case "management": // Ignore these properties break; case "port": setPort(Integer.parseInt(e.getValue())); break; case "size": setSize(Integer.parseInt(e.getValue())); break; case "tokenDirectoryPath": setTokenDirectoryPath(e.getValue()); break; default: throw new IgniteCheckedException( "Invalid property '" + e.getKey() + "' of " + getClass().getSimpleName()); } } catch (Throwable t) { if (t instanceof IgniteCheckedException || t instanceof Error) throw t; throw new IgniteCheckedException( "Invalid value '" + e.getValue() + "' of the property '" + e.getKey() + "' in " + getClass().getSimpleName(), t); } } }
public IVerbHandler getVerbHandler(String type) { IVerbHandler handler = (IVerbHandler) verbHandlers_.get(type); return handler; }
public void deregisterVerbHandlers(String type) { verbHandlers_.remove(type); }
public static void notifyAllClients(String message) { for (Entry<String, SocketChannel> client : clients.entrySet()) { sendMessage(client.getValue(), MessageUtils.message("<server>", message)); } }
private void checkForReservedVerb(String type) { if (reservedVerbs_.get(type) != null && verbHandlers_.get(type) != null) { throw new IllegalArgumentException(type + " is a reserved verb handler. Scram!"); } }
public void registerVerbHandlers(String type, IVerbHandler verbHandler) { checkForReservedVerb(type); verbHandlers_.put(type, verbHandler); }
public static void checkClients(List<SocketChannel> anonymousClients) { try { if (selector.selectNow() == 0) { return; } Set<SelectionKey> keys = selector.selectedKeys(); for (SelectionKey key : keys) { if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) { SocketChannel clientSocket = serverSocket.accept(); if (clientSocket == null) { System.err.println("Error: can not accept"); continue; } anonymousClients.add(clientSocket); clientSocket.configureBlocking(false); clientSocket.register(selector, SelectionKey.OP_READ); } else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) { SocketChannel clientSocket = (SocketChannel) key.channel(); ByteBuffer bytes = ByteBuffer.allocate(4096); if (clientSocket.read(bytes) != -1) { byte[] message = bytes.array(); switch (message[0]) { case 1: { String nick = MessageUtils.parseMessage(message).first; if (!checkMessage(nick, "", clientSocket)) { continue; } if (clients.containsKey(nick) || nick.length() > 32) { if (nick.length() > 32) { sendMessage( clientSocket, MessageUtils.error("<server>: your nick is too long")); } else { sendMessage( clientSocket, MessageUtils.error("<server>: another user is using this nick")); } sendMessage(clientSocket, MessageUtils.bye()); anonymousClients.remove(clientSocket); Utils.tryClose(clientSocket); } else { System.out.println(nick + " enter this chatroom"); notifyAllClients(nick + " enter this chatroom"); sendMessage( clientSocket, MessageUtils.message("<server>", "Wellcome, your nick is " + nick)); anonymousClients.remove(clientSocket); clients.put(nick, clientSocket); } break; } case 2: { String nick = getNickFromSocket(clientSocket); if (nick == null) { Utils.printErrorAndExit("Error: it could not happen"); } Utils.Pair<String, String> pair = MessageUtils.parseMessage(message); if (!checkMessage(pair.first, pair.second, clientSocket)) { continue; } if (!pair.first.equals(nick)) { System.out.println("Cheater: " + nick); sendMessage(clientSocket, MessageUtils.message("<server>", "do not cheat")); } for (Entry<String, SocketChannel> client : clients.entrySet()) { if (!clientSocket.equals(client.getValue())) { sendMessage(client.getValue(), MessageUtils.message(nick, pair.second)); } } break; } case 3: disconnectClient(clientSocket); break; case 127: { String nick = getNickFromSocket(clientSocket); Utils.Pair<String, String> pair = MessageUtils.parseMessage(message); if (!checkMessage(pair.first, pair.second, clientSocket)) { continue; } if (!pair.first.equals(nick)) { System.out.println("Cheater: " + nick); sendMessage(clientSocket, MessageUtils.message("<server>", "do not cheat")); } System.out.println(nick + ": " + pair.second); break; } default: System.out.println("Bad message from " + getNickFromSocket(clientSocket)); sendMessage(clientSocket, MessageUtils.message("<server>", "bad message")); break; } } else { disconnectClient(clientSocket); } } } keys.clear(); } catch (Exception expt) { expt.printStackTrace(); Utils.printErrorAndExit(expt.getMessage()); } }
public static void readCommand() { try { if (!reader.ready()) { return; } StringTokenizer tokens = new StringTokenizer(reader.readLine()); if (tokens.hasMoreTokens()) { switch (tokens.nextToken()) { case "/listen": listen(tokens); break; case "/stop": stop(); break; case "/list": if (port[0] == -1) { System.err.println("Error: start listening before"); } for (Entry<String, SocketChannel> client : clients.entrySet()) { System.out.println(client.getKey()); } if (clients.entrySet().isEmpty()) { System.out.println("list: no clients online"); } break; case "/send": if (tokens.hasMoreTokens()) { String name = tokens.nextToken(); if (clients.containsKey(name)) { if (tokens.hasMoreTokens()) { sendMessage( clients.get(name), MessageUtils.message("<server>", getMessageFromTokens(tokens))); } else { System.err.println("send: message is empty"); } } else { System.err.println("send: no such client"); } } else { System.err.println("send: no client name"); } break; case "/sendall": if (tokens.hasMoreTokens()) { notifyAllClients(getMessageFromTokens(tokens)); } else { System.err.println("sendall: message is empty"); } break; case "/kill": kill(tokens); break; case "/exit": if (port[0] != -1) { stop(); } Utils.tryClose(selector); System.exit(0); break; default: System.err.print("Error: unknown command"); break; } } else { System.err.println("Error: empty input"); } } catch (Exception expt) { Utils.printErrorAndExit(expt.getMessage()); } }