@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);
}
}
}
}*/
}
}
