/*
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
* contributor license agreements. See the NOTICE file distributed with
|
* this work for additional information regarding copyright ownership.
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
* (the "License"); you may not use this file except in compliance with
|
* the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
package websocket.drawboard;
|
|
import java.io.EOFException;
|
import java.io.IOException;
|
|
import javax.websocket.CloseReason;
|
import javax.websocket.Endpoint;
|
import javax.websocket.EndpointConfig;
|
import javax.websocket.MessageHandler;
|
import javax.websocket.Session;
|
|
import org.apache.juli.logging.Log;
|
import org.apache.juli.logging.LogFactory;
|
|
import websocket.drawboard.DrawMessage.ParseException;
|
import websocket.drawboard.wsmessages.StringWebsocketMessage;
|
|
|
public final class DrawboardEndpoint extends Endpoint {
|
|
private static final Log log =
|
LogFactory.getLog(DrawboardEndpoint.class);
|
|
|
/**
|
* Our room where players can join.
|
*/
|
private static volatile Room room = null;
|
private static final Object roomLock = new Object();
|
|
public static Room getRoom(boolean create) {
|
if (create) {
|
if (room == null) {
|
synchronized (roomLock) {
|
if (room == null) {
|
room = new Room();
|
}
|
}
|
}
|
return room;
|
} else {
|
return room;
|
}
|
}
|
|
/**
|
* The player that is associated with this Endpoint and the current room.
|
* Note that this variable is only accessed from the Room Thread.<br><br>
|
*
|
* TODO: Currently, Tomcat uses an Endpoint instance once - however
|
* the java doc of endpoint says:
|
* "Each instance of a websocket endpoint is guaranteed not to be called by
|
* more than one thread at a time per active connection."
|
* This could mean that after calling onClose(), the instance
|
* could be reused for another connection so onOpen() will get called
|
* (possibly from another thread).<br>
|
* If this is the case, we would need a variable holder for the variables
|
* that are accessed by the Room thread, and read the reference to the holder
|
* at the beginning of onOpen, onMessage, onClose methods to ensure the room
|
* thread always gets the correct instance of the variable holder.
|
*/
|
private Room.Player player;
|
|
|
@Override
|
public void onOpen(Session session, EndpointConfig config) {
|
// Set maximum messages size to 10.000 bytes.
|
session.setMaxTextMessageBufferSize(10000);
|
session.addMessageHandler(stringHandler);
|
final Client client = new Client(session);
|
|
final Room room = getRoom(true);
|
room.invokeAndWait(new Runnable() {
|
@Override
|
public void run() {
|
try {
|
|
// Create a new Player and add it to the room.
|
try {
|
player = room.createAndAddPlayer(client);
|
} catch (IllegalStateException ex) {
|
// Probably the max. number of players has been
|
// reached.
|
client.sendMessage(new StringWebsocketMessage(
|
"0" + ex.getLocalizedMessage()));
|
// Close the connection.
|
client.close();
|
}
|
|
} catch (RuntimeException ex) {
|
log.error("Unexpected exception: " + ex.toString(), ex);
|
}
|
}
|
});
|
|
}
|
|
|
@Override
|
public void onClose(Session session, CloseReason closeReason) {
|
Room room = getRoom(false);
|
if (room != null) {
|
room.invokeAndWait(new Runnable() {
|
@Override
|
public void run() {
|
try {
|
// Player can be null if it couldn't enter the room
|
if (player != null) {
|
// Remove this player from the room.
|
player.removeFromRoom();
|
|
// Set player to null to prevent NPEs when onMessage events
|
// are processed (from other threads) after onClose has been
|
// called from different thread which closed the Websocket session.
|
player = null;
|
}
|
} catch (RuntimeException ex) {
|
log.error("Unexpected exception: " + ex.toString(), ex);
|
}
|
}
|
});
|
}
|
}
|
|
|
|
@Override
|
public void onError(Session session, Throwable t) {
|
// Most likely cause is a user closing their browser. Check to see if
|
// the root cause is EOF and if it is ignore it.
|
// Protect against infinite loops.
|
int count = 0;
|
Throwable root = t;
|
while (root.getCause() != null && count < 20) {
|
root = root.getCause();
|
count ++;
|
}
|
if (root instanceof EOFException) {
|
// Assume this is triggered by the user closing their browser and
|
// ignore it.
|
} else if (!session.isOpen() && root instanceof IOException) {
|
// IOException after close. Assume this is a variation of the user
|
// closing their browser (or refreshing very quickly) and ignore it.
|
} else {
|
log.error("onError: " + t.toString(), t);
|
}
|
}
|
|
|
|
private final MessageHandler.Whole<String> stringHandler =
|
new MessageHandler.Whole<String>() {
|
|
@Override
|
public void onMessage(final String message) {
|
// Invoke handling of the message in the room.
|
room.invokeAndWait(new Runnable() {
|
@Override
|
public void run() {
|
try {
|
|
// Currently, the only types of messages the client will send
|
// are draw messages prefixed by a Message ID
|
// (starting with char '1'), and pong messages (starting
|
// with char '0').
|
// Draw messages should look like this:
|
// ID|type,colR,colB,colG,colA,thickness,x1,y1,x2,y2,lastInChain
|
|
boolean dontSwallowException = false;
|
try {
|
char messageType = message.charAt(0);
|
String messageContent = message.substring(1);
|
switch (messageType) {
|
case '0':
|
// Pong message.
|
// Do nothing.
|
break;
|
|
case '1':
|
// Draw message
|
int indexOfChar = messageContent.indexOf('|');
|
long msgId = Long.parseLong(
|
messageContent.substring(0, indexOfChar));
|
|
DrawMessage msg = DrawMessage.parseFromString(
|
messageContent.substring(indexOfChar + 1));
|
|
// Don't ignore RuntimeExceptions thrown by
|
// this method
|
// TODO: Find a better solution than this variable
|
dontSwallowException = true;
|
if (player != null) {
|
player.handleDrawMessage(msg, msgId);
|
}
|
dontSwallowException = false;
|
|
break;
|
}
|
} catch (ParseException e) {
|
// Client sent invalid data
|
// Ignore, TODO: maybe close connection
|
} catch (RuntimeException e) {
|
// Client sent invalid data.
|
// Ignore, TODO: maybe close connection
|
if (dontSwallowException) {
|
throw e;
|
}
|
}
|
|
} catch (RuntimeException ex) {
|
log.error("Unexpected exception: " + ex.toString(), ex);
|
}
|
}
|
});
|
|
}
|
};
|
|
|
}
|
