@Override public AbstractMessage handleIncomingMessage(AbstractMessage incomingMessage) { this.receivedMessagesAverage.inputValue(1); logger.info("in handleIncomingMessage(" + incomingMessage.toString() + ")"); // adds them to a list to see later which got stuck here incomingMessage.setReceiveTimeMillis(Clock.getMainClock().getTimeInMillis(false)); synchronized (receivedMessages) { this.receivedMessages.add(incomingMessage); } // handles the message AbstractMessage replyMessage = null; try { replyMessage = this.handleMessage(incomingMessage); } catch (InterruptedException e) { logger.debug("interrupted"); e.printStackTrace(); } synchronized (receivedMessages) { this.receivedMessages.remove(incomingMessage); } return replyMessage; }
protected AbstractMessage handleMessage(AbstractMessage incomingMessage) throws InterruptedException { // adds message to the right pipeline // BR if (incomingMessage instanceof BlockRequestMessage) { BlockRequestMessage blockRequestMessage = (BlockRequestMessage) incomingMessage; // stats this.videoSignaling.getStats().newIncomingRequest(blockRequestMessage); this.pipelineBlockRequest.offer(incomingMessage); } // USM else if (incomingMessage instanceof SubscribeMessage || incomingMessage instanceof InterestedMessage || incomingMessage instanceof DisconnectMessage && ((DisconnectMessage) incomingMessage).stopUploading()) this.pipelineUploadSlotManager.offer(incomingMessage); // TUNER else if (incomingMessage instanceof PingMessage || incomingMessage instanceof HaveMessage || incomingMessage instanceof SubscribedMessage || incomingMessage instanceof QueuedMessage || incomingMessage instanceof GrantedMessage || incomingMessage instanceof BlockReplyMessage || incomingMessage instanceof PeerSuggestionMessage || incomingMessage instanceof DisconnectMessage && ((DisconnectMessage) incomingMessage).stopDownloading()) this.pipelineTuner.offer(incomingMessage); else { logger.error( "Message of type (" + incomingMessage.getClass().getCanonicalName() + ", " + incomingMessage.toString() + ") is not recognized"); // flow control needs to take its MID not to have a gap this.pipelineUploadSlotManager.offer(incomingMessage); return null; } AbstractMessage replyMessage = null; try { replyMessage = this.waitForProcessingGetReply(incomingMessage); } catch (Exception e) { e.printStackTrace(); logger.error("Error waiting for message to be processed: " + e.getMessage()); } return replyMessage; }
@Override public void onMessage(final String message) { try { AbstractMessage msg = (AbstractMessage) (new XMLBuilder().fromXML(message)); final int requestID = msg.getId(); String messageType = msg.getType(); final String destination = msg.getEndpoint(); switch (messageType) { case "request": { if (DEBUG) System.out.println("Receiving the request: \n" + message); final Request request = (Request) msg; executors.submit( new Callable<Object>() { @Override public Object call() throws Exception { try { Object result = invokeOperation(request.getOpName(), request.getParams()); if (result instanceof OperationAborted) return null; sendResponse(requestID, result, destination); } catch (Exception e) { e.printStackTrace(); } return null; } }); break; } case "response": { if (DEBUG) System.out.println("Receiving the response: \n" + message); Response response = (Response) msg; if (response.getReturnType() != null) { Class<?> type = (Class<?>) response.getReturnType(); results.put(response.getRequestID(), type.cast(response.getReturnValue())); } else { results.put(response.getRequestID(), NullObject); } synchronized (this) { this.notifyAll(); } break; } default: break; } } catch (Exception e) { e.printStackTrace(); } }
public void encode(IoSession session, Object message, ProtocolEncoderOutput output) throws Exception { AbstractMessage msgObj = (AbstractMessage) message; byte[] body = msgObj.encodeBody(); int total = 12 + (body == null ? 0 : body.length); IoBuffer buffer = IoBuffer.allocate(total); buffer.putInt(total); buffer.putInt(msgObj.getCommandId()); buffer.putInt(msgObj.getSequenceId()); if (body != null) buffer.put(body); buffer.flip(); output.write(buffer); }
@Override public void channelRead(ChannelHandlerContext ctx, Object message) { AbstractMessage msg = (AbstractMessage) message; LOG.info("Received a message of type {}", Utils.msgType2String(msg.getMessageType())); try { switch (msg.getMessageType()) { case CONNECT: m_processor.processConnect(ctx.channel(), (ConnectMessage) msg); break; case SUBSCRIBE: m_processor.processSubscribe(ctx.channel(), (SubscribeMessage) msg); break; case UNSUBSCRIBE: m_processor.processUnsubscribe(ctx.channel(), (UnsubscribeMessage) msg); break; case PUBLISH: m_processor.processPublish(ctx.channel(), (PublishMessage) msg); break; case PUBREC: m_processor.processPubRec(ctx.channel(), (PubRecMessage) msg); break; case PUBCOMP: m_processor.processPubComp(ctx.channel(), (PubCompMessage) msg); break; case PUBREL: m_processor.processPubRel(ctx.channel(), (PubRelMessage) msg); break; case DISCONNECT: m_processor.processDisconnect(ctx.channel()); break; case PUBACK: m_processor.processPubAck(ctx.channel(), (PubAckMessage) msg); break; case PINGREQ: PingRespMessage pingResp = new PingRespMessage(); ctx.writeAndFlush(pingResp); break; } } catch (Exception ex) { LOG.error("Bad error in processing the message", ex); } }
@Override public void run() { try { // receivedMessagesAverage logger.info("receivedMessagesAverage: " + receivedMessagesAverage.getAverage()); // print which are unprocessed long currentTime = Clock.getMainClock().getTimeInMillis(false); String debug = ""; synchronized (receivedMessages) { for (AbstractMessage message : receivedMessages) debug += message.toString() + "@" + (message.getReceiveTimeMillis() - currentTime) + ":"; } if (logger.isDebugEnabled()) logger.debug("unprocessed messages: " + debug); } catch (Exception e) { // just so it doesn't die silently if an unhandled exception happened e.printStackTrace(); } }
/** * 释放消息对象 * * @param message */ public final void freeMessage(AbstractMessage message) { // if (message.isPersist()) // { // // 持久时不释放 // return; // } try { message.release(); } catch (Exception e) { logger.error("freeMessage(AbstractMessage) - message=" + message + ". ", e); // $NON-NLS-1$ } }
protected AbstractMessage waitForProcessingGetReply(AbstractMessage incomingMessage) throws InterruptedException { // waits for message to be processed synchronized (incomingMessage) { while (!incomingMessage.isProcessed()) { logger.debug("waiting on: " + incomingMessage); incomingMessage.wait(); } } if (logger.isDebugEnabled()) { logger.debug("done waiting on: " + incomingMessage); } AbstractMessage replyMessage = incomingMessage.getReplyMessage(); if (logger.isDebugEnabled()) { if (replyMessage == null) { logger.debug("will reply NULL to " + incomingMessage); } else { logger.debug("will reply: " + replyMessage + " to " + incomingMessage); } } return replyMessage; }
@Override public void run() { while (running) { AbstractMessage message = null; try { message = pipeline.pollFirst(); // final AbstractMessage finalMessage = message; long t0 = Clock.getMainClock().getTimeInMillis(false); logger.debug("Got message: " + message); processMessage(message); logger.debug( "Done with message: " + message + ", took " + (Clock.getMainClock().getTimeInMillis(false) - t0) + " ms"); } catch (Exception e) { logger.error( "Exception processing message " + e.getMessage() + " caught, continuing with next message"); e.printStackTrace(); } finally { if (message != null) synchronized (message) { logger.debug("setting processed: " + message); message.setProcessed(); message.notify(); } } } }
protected void processMessage(AbstractMessage incomingMessage) { if (incomingMessage.isProcessed() && !(incomingMessage instanceof HaveMessage || incomingMessage instanceof BlockReplyMessage)) return; AbstractMessage replyMessage = null; // USM if (incomingMessage instanceof SubscribeMessage) { replyMessage = this.handleSubscribe((SubscribeMessage) incomingMessage); } else if (incomingMessage instanceof InterestedMessage) { replyMessage = this.handleInterested((InterestedMessage) incomingMessage); } else if (incomingMessage instanceof DisconnectMessage) { DisconnectMessage disconnectMessage = (DisconnectMessage) incomingMessage; if (disconnectMessage.stopUploading()) this.handleDisconnect(disconnectMessage); // TUNER if (disconnectMessage.stopDownloading()) this.handleDisconnect(disconnectMessage); } else if (incomingMessage instanceof HaveMessage) { this.handleHave((HaveMessage) incomingMessage); } else if (incomingMessage instanceof SubscribedMessage) { this.handleSubscribed((SubscribedMessage) incomingMessage); } else if (incomingMessage instanceof QueuedMessage) { this.handleQueued((QueuedMessage) incomingMessage); } else if (incomingMessage instanceof GrantedMessage) { this.handleGranted((GrantedMessage) incomingMessage); } else if (incomingMessage instanceof BlockReplyMessage) { this.handleBlockReply((BlockReplyMessage) incomingMessage); } else if (incomingMessage instanceof PeerSuggestionMessage) { this.handlePeerSuggestion((PeerSuggestionMessage) incomingMessage); } else { logger.warn("Unknown message received, not processing (" + incomingMessage + ")"); } incomingMessage.setReplyMessage(replyMessage, incomingMessage.getSender()); }
@Override public void passivateObject(Object arg0) throws Exception { AbstractMessage message = (AbstractMessage) arg0; message.release(); }
@Override public void sendMessage(String message, String toUser) { message = "加急:" + message; super.sendMessage(message, toUser); }
private void onMessageFromClient(AbstractMessage msg) throws Exception { Container.logger().debug("<<< " + msg); switch (msg.getMessageType()) { case CONNECT: ConnectMessage connect = (ConnectMessage) msg; ConnAckMessage connAck = new ConnAckMessage(); if (session == null) { session = new MQTTSession(vertx, config); session.setPublishMessageHandler(this::sendMessageToClient); session.setKeepaliveErrorHandler( clientID -> { String cinfo = clientID; if (session != null) { cinfo = session.getClientInfo(); } Container.logger() .info("keep alive exausted! closing connection for client[" + cinfo + "] ..."); closeConnection(); }); connAck.setSessionPresent(false); } else { Container.logger().warn("Session alredy allocated ..."); /* The Server MUST process a second CONNECT Packet sent from a Client as a protocol violation and disconnect the Client */ // connAck.setSessionPresent(true);// TODO implement cleanSession=false closeConnection(); break; } session.handleConnectMessage( connect, authenticated -> { if (authenticated) { connAck.setReturnCode(ConnAckMessage.CONNECTION_ACCEPTED); sendMessageToClient(connAck); } else { Container.logger() .error( "Authentication failed! clientID= " + connect.getClientID() + " username="******"type of message not known: " + msg.getClass().getSimpleName()); break; } // TODO: forward mqtt message to backup server }
/** * Sets the content to this <tt>Message</tt>. Used to change the content, before showing action * messages to the user. * * @param messageContent the new message content */ @Override protected void setContent(String messageContent) { super.setContent(messageContent); }
public void handle(AbstractMessage message, Game game) { PlayerConverter playerConverter = new PlayerConverter(); Player player; logger.debug("entered handler" + message.getSession()); logger.debug("entered handler" + message.getSession().getPrincipal().getName()); if ((player = game.getPlayer(message.getSession().getPrincipal().getName())) != null) { game.removePlayer(message.getSession().getPrincipal().getName()); logger.debug("now players size is" + game.getPlayers().size()); /*if (game.getPlayers().size() < 2) { logger.debug("less than 2 players remains"); game.setState(Finished.class); logger.debug("game is ended"); //GameFinished gameFinished = new GameFinished(GameFinished.Status.TOO_LITTLE_USERS); for (Player p : game.getPlayers().values()) { if (p.getState() != Player.State.ONLINE) { continue; } try { p.getWebSocketSession().sendMessage(new TextMessage(objectMapper.writeValueAsString(gameFinished))); } catch (IOException e) { UserOccasionallyDisconnected userOccasionallyDisconnected = new UserOccasionallyDisconnected(); userOccasionallyDisconnected.setSession(message.getSession()); playerConnectorOrGameRemover.handle(userOccasionallyDisconnected); } } playerConnectorOrGameRemover.handle(new RemoveGameRequest(game)); } else { if (checkIfWaitingUsersExists(game)) { logger.debug("waiting users exists"); GameStateUpdateMessage gameStateUpdateMessage = new GameStateUpdateMessage(playerConverter.convert(new ArrayList<Player>(game.getPlayers().values())),game.getState()); for (Player p : game.getPlayers().values()) { if (p.getState() != Player.State.ONLINE) { continue; } try { p.getWebSocketSession().sendMessage(new TextMessage(objectMapper.writeValueAsString(gameStateUpdateMessage))); } catch (IOException e) { UserOccasionallyDisconnected userOccasionallyDisconnected = new UserOccasionallyDisconnected(); userOccasionallyDisconnected.setSession(message.getSession()); playerConnectorOrGameRemover.handle(userOccasionallyDisconnected); } } } else { logger.debug("no waiting users more, can continue"); game.restoreState(); logger.debug("restored state "+game.getState()); GameStateUpdateMessage gameStateUpdateMessage = new GameStateUpdateMessage(playerConverter.convert(new ArrayList<Player>(game.getPlayers().values())),game.getState()); for (Player p : game.getPlayers().values()) { if (p.getState() != Player.State.ONLINE) { continue; } try { p.getWebSocketSession().sendMessage(new TextMessage(objectMapper.writeValueAsString(gameStateUpdateMessage))); } catch (IOException e) { UserOccasionallyDisconnected userOccasionallyDisconnected = new UserOccasionallyDisconnected(); userOccasionallyDisconnected.setSession(message.getSession()); playerConnectorOrGameRemover.handle(userOccasionallyDisconnected); } } } }*/ } }