External/mage
1
0
Fork 1
mirror of https://github.com/magefree/mage.git synced 2025-12-25 13:02:06 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

integrated jboss remoting

Browse source
This commit is contained in:
BetaSteward 2011-06-22 22:37:50 -04:00
parent 34cd3bbcdc
commit 05be0a14ed
36 changed files with 1356 additions and 2061 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Mage.Server/src/main/java/mage/server/ChatManager.java
View file

@ -54,11 +54,11 @@ public class ChatManager {
return chatSession.getChatId();
}
public void joinChat(UUID chatId, UUID sessionId, String userName) {
public void joinChat(UUID chatId, String sessionId, String userName) {
chatSessions.get(chatId).join(userName, sessionId);
}
public void leaveChat(UUID chatId, UUID sessionId) {
public void leaveChat(UUID chatId, String sessionId) {
chatSessions.get(chatId).kill(sessionId);
}
@ -70,7 +70,7 @@ public class ChatManager {
chatSessions.get(chatId).broadcast(userName, message, color);
}
void removeSession(UUID sessionId) {
void removeSession(String sessionId) {
for (ChatSession chat: chatSessions.values()) {
chat.kill(sessionId);
}

10
Mage.Server/src/main/java/mage/server/ChatSession.java
View file

@ -34,8 +34,6 @@ import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.view.ChatMessage;
import mage.view.ChatMessage.MessageColor;
@ -48,7 +46,7 @@ import org.apache.log4j.Logger;
public class ChatSession {
private final static Logger logger = Logger.getLogger(ChatSession.class);
private ConcurrentHashMap<UUID, String> clients = new ConcurrentHashMap<UUID, String>();
private ConcurrentHashMap<String, String> clients = new ConcurrentHashMap<String, String>();
private UUID chatId;
private DateFormat timeFormatter = SimpleDateFormat.getTimeInstance(SimpleDateFormat.SHORT);
@ -58,13 +56,13 @@ public class ChatSession {
chatId = UUID.randomUUID();
}
public void join(String userName, UUID sessionId) {
public void join(String userName, String sessionId) {
clients.put(sessionId, userName);
broadcast(userName, " has joined", MessageColor.BLACK);
logger.info(userName + " joined chat " + chatId);
}
public void kill(UUID sessionId) {
public void kill(String sessionId) {
if (clients.containsKey(sessionId)) {
String userName = clients.get(sessionId);
clients.remove(sessionId);
@ -79,7 +77,7 @@ public class ChatSession {
final String time = timeFormatter.format(cal.getTime());
final String username = userName;
logger.debug("Broadcasting '" + msg + "' for " + chatId);
for (UUID sessionId: clients.keySet()) {
for (String sessionId: clients.keySet()) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null)
session.fireCallback(new ClientCallback("chatMessage", chatId, new ChatMessage(username, msg, time, color)));

172
Mage.Server/src/main/java/mage/server/ServerImpl.java → Mage.Server/src/main/java/mage/server/MageServerImpl.java
View file

@ -28,12 +28,6 @@
package mage.server;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.ExportException;
import java.rmi.server.RemoteServer;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@ -43,9 +37,9 @@ import mage.cards.decks.DeckCardLists;
import mage.game.GameException;
import mage.game.match.MatchOptions;
import mage.game.tournament.TournamentOptions;
import mage.interfaces.Server;
import mage.interfaces.MageServer;
//import mage.interfaces.Server;
import mage.interfaces.ServerState;
import mage.interfaces.callback.ClientCallback;
import mage.server.game.DeckValidatorFactory;
import mage.server.draft.DraftManager;
import mage.server.game.GameFactory;
@ -69,94 +63,48 @@ import org.apache.log4j.Logger;
*
* @author BetaSteward_at_googlemail.com
*/
public class ServerImpl extends RemoteServer implements Server {
public class MageServerImpl implements MageServer {
private final static Logger logger = Logger.getLogger("Mage Server");
private static ExecutorService rmiExecutor = ThreadExecutor.getInstance().getRMIExecutor();
private boolean testMode;
private String password;
private boolean testMode;
public MageServerImpl(String password, boolean testMode) {
this.password = password;
this.testMode = testMode;
}
@Override
public boolean registerClient(String userName, String sessionId, MageVersion version) throws MageException {
public ServerImpl(int port, String name, boolean testMode, String password) {
try {
System.setSecurityManager(null);
Registry reg = LocateRegistry.createRegistry(port);
Server stub = (Server) UnicastRemoteObject.exportObject(this, port);
reg.rebind(name, stub);
this.testMode = testMode;
this.password = password;
logger.info("Started MAGE server - listening on port " + port);
if (testMode)
logger.info("MAGE server running in test mode");
} catch (ExportException ex) {
logger.fatal("ERROR: Unable to start Mage Server - another server is likely running");
} catch (RemoteException ex) {
logger.fatal("Failed to start RMI server at port " + port, ex);
}
}
public boolean isTestMode() {
return testMode;
}
@Override
public ClientCallback callback(UUID sessionId) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session == null) {
return null;
}
return session.callback();
}
@Override
public void ack(String message, UUID sessionId) throws RemoteException, MageException {
SessionManager.getInstance().getSession(sessionId).ack(message);
}
@Override
public boolean ping(UUID sessionId) {
Session session = SessionManager.getInstance().getSession(sessionId);
if (session != null) {
session.ping();
return true;
if (version.compareTo(Main.getVersion()) != 0)
throw new MageException("Wrong client version " + version + ", expecting version " + Main.getVersion());
return SessionManager.getInstance().registerUser(sessionId, userName);
} catch (Exception ex) {
handleException(ex);
}
return false;
}
@Override
public UUID registerClient(String userName, UUID clientId, MageVersion version) throws MageException, RemoteException {
UUID sessionId = null;
try {
if (version.compareTo(Main.getVersion()) != 0)
throw new MageException("Wrong client version " + version + ", expecting version " + Main.getVersion());
sessionId = SessionManager.getInstance().createSession(userName, getClientHost(), clientId);
logger.info("User " + userName + " connected from " + getClientHost());
} catch (Exception ex) {
handleException(ex);
}
return sessionId;
}
@Override
public UUID registerAdmin(String password, MageVersion version) throws RemoteException, MageException {
UUID sessionId = null;
public boolean registerAdmin(String password, String sessionId, MageVersion version) throws MageException {
try {
if (version.compareTo(Main.getVersion()) != 0)
throw new MageException("Wrong client version " + version + ", expecting version " + Main.getVersion());
if (!password.equals(this.password))
throw new MageException("Wrong password");
sessionId = SessionManager.getInstance().createSession(getClientHost());
logger.info("Admin connected from " + getClientHost());
return SessionManager.getInstance().registerAdmin(sessionId);
} catch (Exception ex) {
handleException(ex);
}
return sessionId;
return false;
}
@Override
public TableView createTable(UUID sessionId, UUID roomId, MatchOptions options) throws MageException {
public TableView createTable(String sessionId, UUID roomId, MatchOptions options) throws MageException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
TableView table = GamesRoomManager.getInstance().getRoom(roomId).createTable(sessionId, options);
@ -171,7 +119,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public TableView createTournamentTable(UUID sessionId, UUID roomId, TournamentOptions options) throws MageException {
public TableView createTournamentTable(String sessionId, UUID roomId, TournamentOptions options) throws MageException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
TableView table = GamesRoomManager.getInstance().getRoom(roomId).createTournamentTable(sessionId, options);
@ -186,7 +134,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void removeTable(final UUID sessionId, final UUID roomId, final UUID tableId) throws MageException {
public void removeTable(final String sessionId, final UUID roomId, final UUID tableId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -205,7 +153,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean joinTable(UUID sessionId, UUID roomId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException, GameException {
public boolean joinTable(String sessionId, UUID roomId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException, GameException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
boolean ret = GamesRoomManager.getInstance().getRoom(roomId).joinTable(sessionId, tableId, name, playerType, skill, deckList);
@ -222,7 +170,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean joinTournamentTable(UUID sessionId, UUID roomId, UUID tableId, String name, String playerType, int skill) throws MageException, GameException {
public boolean joinTournamentTable(String sessionId, UUID roomId, UUID tableId, String name, String playerType, int skill) throws MageException, GameException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
boolean ret = GamesRoomManager.getInstance().getRoom(roomId).joinTournamentTable(sessionId, tableId, name, playerType, skill);
@ -239,7 +187,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean submitDeck(UUID sessionId, UUID tableId, DeckCardLists deckList) throws MageException, GameException {
public boolean submitDeck(String sessionId, UUID tableId, DeckCardLists deckList) throws MageException, GameException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
boolean ret = TableManager.getInstance().submitDeck(sessionId, tableId, deckList);
@ -293,7 +241,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void deregisterClient(final UUID sessionId) throws MageException {
public void deregisterClient(final String sessionId) throws MageException {
try {
rmiExecutor.execute(
new Runnable() {
@ -314,7 +262,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void startMatch(final UUID sessionId, final UUID roomId, final UUID tableId) throws MageException {
public void startMatch(final String sessionId, final UUID roomId, final UUID tableId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -333,7 +281,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void startChallenge(final UUID sessionId, final UUID roomId, final UUID tableId, final UUID challengeId) throws RemoteException, MageException {
public void startChallenge(final String sessionId, final UUID roomId, final UUID tableId, final UUID challengeId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -352,7 +300,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void startTournament(final UUID sessionId, final UUID roomId, final UUID tableId) throws MageException {
public void startTournament(final String sessionId, final UUID roomId, final UUID tableId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -371,7 +319,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public TournamentView getTournament(UUID tournamentId) throws RemoteException, MageException {
public TournamentView getTournament(UUID tournamentId) throws MageException {
try {
return TournamentManager.getInstance().getTournamentView(tournamentId);
}
@ -399,7 +347,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void joinChat(final UUID chatId, final UUID sessionId, final String userName) throws MageException {
public void joinChat(final UUID chatId, final String sessionId, final String userName) throws MageException {
try {
rmiExecutor.execute(
new Runnable() {
@ -416,7 +364,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void leaveChat(final UUID chatId, final UUID sessionId) throws MageException {
public void leaveChat(final UUID chatId, final String sessionId) throws MageException {
try {
rmiExecutor.execute(
new Runnable() {
@ -455,7 +403,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean isTableOwner(UUID sessionId, UUID roomId, UUID tableId) throws MageException {
public boolean isTableOwner(String sessionId, UUID roomId, UUID tableId) throws MageException {
try {
return TableManager.getInstance().isTableOwner(tableId, sessionId);
}
@ -466,7 +414,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void swapSeats(final UUID sessionId, final UUID roomId, final UUID tableId, final int seatNum1, final int seatNum2) throws RemoteException, MageException {
public void swapSeats(final String sessionId, final UUID roomId, final UUID tableId, final int seatNum1, final int seatNum2) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -485,7 +433,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void leaveTable(final UUID sessionId, final UUID roomId, final UUID tableId) throws MageException {
public void leaveTable(final String sessionId, final UUID roomId, final UUID tableId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -515,7 +463,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void joinGame(final UUID gameId, final UUID sessionId) throws MageException {
public void joinGame(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -534,7 +482,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void joinDraft(final UUID draftId, final UUID sessionId) throws MageException {
public void joinDraft(final UUID draftId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -553,7 +501,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void joinTournament(final UUID tournamentId, final UUID sessionId) throws MageException {
public void joinTournament(final UUID tournamentId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -594,7 +542,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void sendPlayerUUID(final UUID gameId, final UUID sessionId, final UUID data) throws MageException {
public void sendPlayerUUID(final UUID gameId, final String sessionId, final UUID data) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -613,7 +561,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void sendPlayerString(final UUID gameId, final UUID sessionId, final String data) throws MageException {
public void sendPlayerString(final UUID gameId, final String sessionId, final String data) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -632,7 +580,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void sendPlayerBoolean(final UUID gameId, final UUID sessionId, final Boolean data) throws MageException {
public void sendPlayerBoolean(final UUID gameId, final String sessionId, final Boolean data) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -651,7 +599,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void sendPlayerInteger(final UUID gameId, final UUID sessionId, final Integer data) throws RemoteException, MageException {
public void sendPlayerInteger(final UUID gameId, final String sessionId, final Integer data) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -670,7 +618,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public DraftPickView sendCardPick(final UUID draftId, final UUID sessionId, final UUID cardPick) throws MageException {
public DraftPickView sendCardPick(final UUID draftId, final String sessionId, final UUID cardPick) throws MageException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
return DraftManager.getInstance().sendCardPick(draftId, sessionId, cardPick);
@ -683,7 +631,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void concedeGame(final UUID gameId, final UUID sessionId) throws MageException {
public void concedeGame(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -702,7 +650,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean watchTable(UUID sessionId, UUID roomId, UUID tableId) throws MageException {
public boolean watchTable(String sessionId, UUID roomId, UUID tableId) throws MageException {
try {
if (SessionManager.getInstance().isValidSession(sessionId)) {
return GamesRoomManager.getInstance().getRoom(roomId).watchTable(sessionId, tableId);
@ -715,7 +663,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void watchGame(final UUID gameId, final UUID sessionId) throws MageException {
public void watchGame(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -734,7 +682,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void stopWatching(final UUID gameId, final UUID sessionId) throws MageException {
public void stopWatching(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -753,7 +701,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void replayGame(final UUID gameId, final UUID sessionId) throws MageException {
public void replayGame(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -772,7 +720,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void startReplay(final UUID gameId, final UUID sessionId) throws MageException {
public void startReplay(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -791,7 +739,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void stopReplay(final UUID gameId, final UUID sessionId) throws MageException {
public void stopReplay(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -810,7 +758,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void nextPlay(final UUID gameId, final UUID sessionId) throws MageException {
public void nextPlay(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -829,7 +777,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void previousPlay(final UUID gameId, final UUID sessionId) throws MageException {
public void previousPlay(final UUID gameId, final String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -848,7 +796,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public ServerState getServerState() throws RemoteException, MageException {
public ServerState getServerState() throws MageException {
try {
return new ServerState(
GameFactory.getInstance().getGameTypes(),
@ -865,7 +813,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void cheat(final UUID gameId, final UUID sessionId, final UUID playerId, final DeckCardLists deckList) throws MageException {
public void cheat(final UUID gameId, final String sessionId, final UUID playerId, final DeckCardLists deckList) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -885,7 +833,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public boolean cheat(final UUID gameId, final UUID sessionId, final UUID playerId, final String cardName) throws MageException {
public boolean cheat(final UUID gameId, final String sessionId, final UUID playerId, final String cardName) throws MageException {
if (testMode) {
if (SessionManager.getInstance().isValidSession(sessionId)) {
return GameManager.getInstance().cheat(gameId, sessionId, playerId, cardName);
@ -900,7 +848,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public GameView getGameView(final UUID gameId, final UUID sessionId, final UUID playerId) {
public GameView getGameView(final UUID gameId, final String sessionId, final UUID playerId) {
if (SessionManager.getInstance().isValidSession(sessionId)) {
return GameManager.getInstance().getGameView(gameId, sessionId, playerId);
}
@ -908,7 +856,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public List<UserView> getUsers(UUID sessionId) throws RemoteException, MageException {
public List<UserView> getUsers(String sessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
return SessionManager.getInstance().getUsers(sessionId);
}
@ -916,7 +864,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void disconnectUser(final UUID sessionId, final UUID userSessionId) throws RemoteException, MageException {
public void disconnectUser(final String sessionId, final String userSessionId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(
@ -935,7 +883,7 @@ public class ServerImpl extends RemoteServer implements Server {
}
@Override
public void removeTable(final UUID sessionId, final UUID tableId) throws RemoteException, MageException {
public void removeTable(final String sessionId, final UUID tableId) throws MageException {
if (SessionManager.getInstance().isValidSession(sessionId)) {
try {
rmiExecutor.execute(

143
Mage.Server/src/main/java/mage/server/Main.java
View file

@ -37,8 +37,11 @@ import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.Map;
import javax.management.MBeanServer;
import mage.game.match.MatchType;
import mage.game.tournament.TournamentType;
import mage.interfaces.MageServer;
import mage.server.game.DeckValidatorFactory;
import mage.server.game.GameFactory;
import mage.server.game.PlayerFactory;
@ -46,9 +49,17 @@ import mage.server.tournament.TournamentFactory;
import mage.server.util.ConfigSettings;
import mage.server.util.config.Plugin;
import mage.server.util.config.GamePlugin;
import mage.util.Copier;
import mage.utils.MageVersion;
import org.apache.log4j.Logger;
import org.jboss.remoting.InvocationRequest;
import org.jboss.remoting.InvokerLocator;
import org.jboss.remoting.ServerInvocationHandler;
import org.jboss.remoting.ServerInvoker;
import org.jboss.remoting.callback.InvokerCallbackHandler;
import org.jboss.remoting.callback.ServerInvokerCallbackHandler;
import org.jboss.remoting.transport.Connector;
import org.jboss.remoting.transporter.TransporterServer;
import org.w3c.dom.Element;
/**
*
@ -61,11 +72,11 @@ public class Main {
private final static String testModeArg = "-testMode=";
private final static String adminPasswordArg = "-adminPassword=";
private final static String pluginFolder = "plugins";
private static MageVersion version = new MageVersion(0, 7, 4, "beta-2");
private static MageVersion version = new MageVersion(0, 8, 0, "");
public static PluginClassLoader classLoader = new PluginClassLoader();
public static ServerImpl server;
public static TransporterServer server;
protected static boolean testMode;
/**
* @param args the command line arguments
*/
@ -87,7 +98,6 @@ public class Main {
for (Plugin plugin: config.getDeckTypes()) {
DeckValidatorFactory.getInstance().addDeckType(plugin.getName(), loadPlugin(plugin));
}
boolean testMode = false;
String adminPassword = "";
for (String arg: args) {
if (arg.startsWith(testModeArg)) {
@ -97,44 +107,102 @@ public class Main {
adminPassword = arg.replace(adminPasswordArg, "");
}
}
Copier.setLoader(classLoader);
setServerAddress(config.getServerAddress());
server = new ServerImpl(config.getPort(), config.getServerName(), testMode, adminPassword);
String host = getServerAddress();
int port = config.getPort();
String locatorURI = "bisocket://" + host + ":" + port;
try {
InvokerLocator serverLocator = new InvokerLocator(locatorURI);
server = new MageTransporterServer(serverLocator, new MageServerImpl(adminPassword, testMode), MageServer.class.getName(), new MageServerInvocationHandler());
server.start();
logger.info("Started MAGE server - listening on " + host + ":" + port);
if (testMode)
logger.info("MAGE server running in test mode");
} catch (Exception ex) {
logger.fatal("Failed to start server - " + host + ":" + port, ex);
}
}
private static void setServerAddress(String ip) {
String ipParam = System.getProperty("server");
if (ipParam != null) {
ip = ipParam;
static class MageTransporterServer extends TransporterServer {
Connector connector;
public MageTransporterServer(InvokerLocator locator, Object target, String subsystem, MageServerInvocationHandler callback) throws Exception {
super(locator, target, subsystem);
connector.addInvocationHandler("callback", callback);
}
if (ip.equals("localhost")) {
public Connector getConnector() throws Exception {
return connector;
}
@Override
protected Connector getConnector(InvokerLocator locator, Map config, Element xmlConfig) throws Exception {
Connector c = super.getConnector(locator, config, xmlConfig);
this.connector = c;
return c;
}
}
static class MageServerInvocationHandler implements ServerInvocationHandler {
@Override
public void setMBeanServer(MBeanServer server) {}
@Override
public void setInvoker(ServerInvoker invoker) {}
@Override
public Object invoke(final InvocationRequest invocation) throws Throwable {
return null;
}
@Override
public void addListener(InvokerCallbackHandler callbackHandler) {
ServerInvokerCallbackHandler handler = (ServerInvokerCallbackHandler) callbackHandler;
try {
String foundIP = "";
for (Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); interfaces.hasMoreElements(); ) {
NetworkInterface iface = interfaces.nextElement( );
if (iface.isLoopback())
continue;
for (InterfaceAddress addr: iface.getInterfaceAddresses())
{
InetAddress iaddr = addr.getAddress();
if (iaddr instanceof Inet4Address) {
foundIP = iaddr.getHostAddress();
break;
}
}
if (foundIP.length() > 0)
break;
}
if (foundIP.length() > 0)
ip = foundIP;
} catch (SocketException ex) {
logger.warn("Could not get server address: ", ex);
String sessionId = handler.getClientSessionId();
InetAddress clientAddress = handler.getCallbackClient().getAddressSeenByServer();
SessionManager.getInstance().createSession(sessionId, callbackHandler, clientAddress.getHostAddress());
} catch (Throwable ex) {
logger.fatal("", ex);
}
}
System.setProperty("java.rmi.server.hostname", ip);
System.setProperty("sun.rmi.transport.tcp.readTimeout", "30000");
logger.info("MAGE server - using address " + ip);
@Override
public void removeListener(InvokerCallbackHandler callbackHandler) {
ServerInvokerCallbackHandler handler = (ServerInvokerCallbackHandler) callbackHandler;
String sessionId = handler.getCallbackClient().getSessionId();
SessionManager.getInstance().removeSession(sessionId);
}
}
private static String getServerAddress() {
try {
String foundIP = "";
for (Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); interfaces.hasMoreElements(); ) {
NetworkInterface iface = interfaces.nextElement( );
if (iface.isLoopback())
continue;
for (InterfaceAddress addr: iface.getInterfaceAddresses())
{
InetAddress iaddr = addr.getAddress();
if (iaddr instanceof Inet4Address) {
foundIP = iaddr.getHostAddress();
break;
}
}
if (foundIP.length() > 0)
break;
}
if (foundIP.length() > 0)
return foundIP;
} catch (SocketException ex) {
logger.warn("Could not get server address: ", ex);
}
return null;
}
private static Class<?> loadPlugin(Plugin plugin) {
@ -198,4 +266,7 @@ public class Main {
return version;
}
public static boolean isTestMode() {
return testMode;
}
}

83
Mage.Server/src/main/java/mage/server/Session.java
View file

@ -31,11 +31,14 @@ package mage.server;
import java.util.Date;
import java.util.UUID;
import mage.cards.decks.Deck;
import mage.interfaces.callback.CallbackServerSession;
import mage.interfaces.callback.ClientCallback;
import mage.server.game.GameManager;
import mage.view.TableClientMessage;
import org.apache.log4j.Logger;
import org.jboss.remoting.callback.AsynchInvokerCallbackHandler;
import org.jboss.remoting.callback.Callback;
import org.jboss.remoting.callback.HandleCallbackException;
import org.jboss.remoting.callback.InvokerCallbackHandler;
/**
*
@ -45,68 +48,46 @@ public class Session {
private final static Logger logger = Logger.getLogger(Session.class);
private UUID sessionId;
private UUID clientId;
private String sessionId;
private String username;
private String host;
private int messageId = 0;
private String ackMessage;
private Date timeConnected;
private long lastPing;
private boolean isAdmin = false;
private final CallbackServerSession callback = new CallbackServerSession();
private AsynchInvokerCallbackHandler callbackHandler;
public Session(String userName, String host, UUID clientId) {
sessionId = UUID.randomUUID();
this.username = userName;
public Session(String sessionId, InvokerCallbackHandler callbackHandler, String host) {
this.sessionId = sessionId;
this.callbackHandler = (AsynchInvokerCallbackHandler) callbackHandler;
this.host = host;
this.clientId = clientId;
this.isAdmin = false;
this.timeConnected = new Date();
ping();
}
public Session(String host) {
sessionId = UUID.randomUUID();
this.username = "Admin";
this.host = host;
public void registerUser(String userName) {
this.isAdmin = false;
this.username = userName;
}
public void registerAdmin() {
this.isAdmin = true;
this.timeConnected = new Date();
ping();
this.username = "Admin";
}
public UUID getId() {
public String getId() {
return sessionId;
}
public UUID getClientId() {
return clientId;
}
public void kill() {
callback.destroy();
SessionManager.getInstance().removeSession(sessionId);
TableManager.getInstance().removeSession(sessionId);
GameManager.getInstance().removeSession(sessionId);
ChatManager.getInstance().removeSession(sessionId);
}
public ClientCallback callback() {
try {
return callback.callback();
} catch (InterruptedException ex) {
logger.fatal("Session callback error", ex);
}
return null;
}
public synchronized void fireCallback(final ClientCallback call) {
call.setMessageId(messageId++);
if (logger.isDebugEnabled())
logger.debug(sessionId + " - " + call.getMessageId() + " - " + call.getMethod());
try {
callback.setCallback(call);
} catch (InterruptedException ex) {
callbackHandler.handleCallbackOneway(new Callback(call));
} catch (HandleCallbackException ex) {
logger.fatal("Session fireCallback error", ex);
}
}
@ -139,32 +120,10 @@ public class Session {
fireCallback(new ClientCallback("replayGame", gameId));
}
public void ack(String message) {
this.ackMessage = message;
}
public String getAckMessage() {
return ackMessage;
}
public void clearAck() {
this.ackMessage = "";
}
public String getUsername() {
return username;
}
public void ping() {
this.lastPing = System.currentTimeMillis();
if (logger.isTraceEnabled())
logger.trace("Ping received from" + username + ":" + sessionId);
}
public boolean stillAlive() {
return (System.currentTimeMillis() - lastPing) < 60000;
}
public boolean isAdmin() {
return isAdmin;
}

105
Mage.Server/src/main/java/mage/server/SessionManager.java
View file

@ -32,14 +32,10 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import mage.MageException;
import mage.view.UserView;
import org.apache.log4j.Logger;
import org.jboss.remoting.callback.InvokerCallbackHandler;
/**
*
@ -49,83 +45,67 @@ public class SessionManager {
private final static Logger logger = Logger.getLogger(SessionManager.class);
private final static SessionManager INSTANCE = new SessionManager();
private static ScheduledExecutorService sessionExecutor;
public static SessionManager getInstance() {
return INSTANCE;
}
protected SessionManager() {
sessionExecutor = Executors.newScheduledThreadPool(1);
sessionExecutor.scheduleWithFixedDelay(new SessionChecker(), 30, 10, TimeUnit.SECONDS);
}
private ConcurrentHashMap<String, Session> sessions = new ConcurrentHashMap<String, Session>();
private ConcurrentHashMap<UUID, Session> sessions = new ConcurrentHashMap<UUID, Session>();
public Session getSession(UUID sessionId) {
public Session getSession(String sessionId) {
if (sessions == null || sessionId == null) return null;
return sessions.get(sessionId);
}
public UUID createSession(String userName, String host, UUID clientId) throws MageException {
for (Session session: sessions.values()) {
if (session.getUsername().equals(userName)) {
if (session.getClientId().equals(clientId)) {
logger.info("Reconnecting session " + session.getId() + " for " + userName);
return session.getId();
}
else {
throw new MageException("User name already in use");
}
}
}
Session session = new Session(userName, host, clientId);
sessions.put(session.getId(), session);
logger.info("Session " + session.getId() + " created for user " + userName);
return session.getId();
}
public UUID createSession(String host) throws MageException {
Session session = new Session(host);
sessions.put(session.getId(), session);
logger.info("Admin session created");
return session.getId();
}
public void removeSession(UUID sessionId) {
sessions.remove(sessionId);
}
public void checkSessions() {
logger.trace("Checking sessions");
for (Session session: sessions.values()) {
if (!session.stillAlive()) {
logger.info("Client for user " + session.getUsername() + ":" + session.getId() + " timed out - releasing resources");
session.kill();
}
}
public void createSession(String sessionId, InvokerCallbackHandler callbackHandler, String host) {
Session session = new Session(sessionId, callbackHandler, host);
sessions.put(sessionId, session);
}
public Map<UUID, Session> getSessions() {
Map<UUID, Session> map = new HashMap<UUID, Session>();
for (Map.Entry<UUID, Session> entry : sessions.entrySet()) {
public boolean registerUser(String sessionId, String userName) {
Session session = sessions.get(sessionId);
if (session != null) {
session.registerUser(userName);
logger.info("User " + userName + " connected from " + session.getHost());
return true;
}
return false;
}
public boolean registerAdmin(String sessionId) {
Session session = sessions.get(sessionId);
if (session != null) {
session.registerAdmin();
logger.info("Admin connected from " + session.getHost());
return true;
}
return false;
}
public void removeSession(String sessionId) {
sessions.remove(sessionId);
}
public Map<String, Session> getSessions() {
Map<String, Session> map = new HashMap<String, Session>();
for (Map.Entry<String, Session> entry : sessions.entrySet()) {
map.put(entry.getKey(), entry.getValue());
}
return map;
}
List<UserView> getUsers(UUID sessionId) {
List<UserView> getUsers(String sessionId) {
List<UserView> users = new ArrayList<UserView>();
Session admin = sessions.get(sessionId);
if (admin != null && admin.isAdmin()) {
for (Session session: sessions.values()) {
users.add(new UserView(session.getUsername(), session.getHost(), session.getId(), session.getConnectionTime()));
users.add(new UserView(session.getUsername(), "", session.getId(), session.getConnectionTime()));
}
}
return users;
}
public void disconnectUser(UUID sessionId, UUID userSessionId) {
public void disconnectUser(String sessionId, String userSessionId) {
if (isAdmin(sessionId)) {
Session session = sessions.get(userSessionId);
if (session != null) {
@ -134,7 +114,7 @@ public class SessionManager {
}
}
public boolean isAdmin(UUID sessionId) {
public boolean isAdmin(String sessionId) {
Session admin = sessions.get(sessionId);
if (admin != null) {
return admin.isAdmin();
@ -142,19 +122,10 @@ public class SessionManager {
return false;
}
public boolean isValidSession(UUID sessionId) {
public boolean isValidSession(String sessionId) {
if (sessions.containsKey(sessionId))
return true;
return false;
}
class SessionChecker implements Runnable {
@Override
public void run() {
checkSessions();
}
}
}

60
Mage.Server/src/main/java/mage/server/TableController.java
View file

@ -67,16 +67,16 @@ public class TableController {
private final static Logger logger = Logger.getLogger(TableController.class);
private UUID sessionId;
private String sessionId;
private UUID chatId;
private String controllerName;
private Table table;
private Match match;
private MatchOptions options;
private Tournament tournament;
private ConcurrentHashMap<UUID, UUID> sessionPlayerMap = new ConcurrentHashMap<UUID, UUID>();
private ConcurrentHashMap<String, UUID> sessionPlayerMap = new ConcurrentHashMap<String, UUID>();
public TableController(UUID roomId, UUID sessionId, MatchOptions options) {
public TableController(UUID roomId, String sessionId, MatchOptions options) {
this.sessionId = sessionId;
chatId = ChatManager.getInstance().createChatSession();
this.options = options;
@ -90,7 +90,7 @@ public class TableController {
init();
}
public TableController(UUID roomId, UUID sessionId, TournamentOptions options) {
public TableController(UUID roomId, String sessionId, TournamentOptions options) {
this.sessionId = sessionId;
chatId = ChatManager.getInstance().createChatSession();
tournament = TournamentFactory.getInstance().createTournament(options.getTournamentType(), options);
@ -124,7 +124,7 @@ public class TableController {
);
}
public synchronized boolean joinTournament(UUID sessionId, String name, String playerType, int skill) throws GameException {
public synchronized boolean joinTournament(String sessionId, String name, String playerType, int skill) throws GameException {
if (table.getState() != TableState.WAITING) {
return false;
}
@ -144,7 +144,7 @@ public class TableController {
return true;
}
public synchronized boolean joinTable(UUID sessionId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
public synchronized boolean joinTable(String sessionId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
if (table.getState() != TableState.WAITING) {
return false;
}
@ -153,7 +153,7 @@ public class TableController {
throw new GameException("No available seats.");
}
Deck deck = Deck.load(deckList);
if (!Main.server.isTestMode() && !table.getValidator().validate(deck)) {
if (!Main.isTestMode() && !table.getValidator().validate(deck)) {
throw new InvalidDeckException(name + " has an invalid deck for this format", table.getValidator().getInvalid());
}
@ -169,7 +169,7 @@ public class TableController {
return true;
}
public void addPlayer(UUID sessionId, Player player, String playerType, Deck deck) throws GameException {
public void addPlayer(String sessionId, Player player, String playerType, Deck deck) throws GameException {
if (table.getState() != TableState.WAITING) {
return;
}
@ -183,29 +183,33 @@ public class TableController {
sessionPlayerMap.put(sessionId, player.getId());
}
}
public boolean submitDeck(String sessionId, DeckCardLists deckList) throws MageException {
return submitDeck(sessionPlayerMap.get(sessionId), deckList);
}
public synchronized boolean submitDeck(UUID sessionId, DeckCardLists deckList) throws MageException {
public synchronized boolean submitDeck(UUID playerId, DeckCardLists deckList) throws MageException {
if (table.getState() != TableState.SIDEBOARDING && table.getState() != TableState.CONSTRUCTING) {
return false;
}
Deck deck = Deck.load(deckList);
if (!Main.server.isTestMode() && !table.getValidator().validate(deck)) {
if (!Main.isTestMode() && !table.getValidator().validate(deck)) {
throw new InvalidDeckException("Invalid deck for this format", table.getValidator().getInvalid());
}
submitDeck(sessionId, deck);
submitDeck(playerId, deck);
return true;
}
private void submitDeck(UUID sessionId, Deck deck) {
private void submitDeck(UUID playerId, Deck deck) {
if (table.getState() == TableState.SIDEBOARDING) {
match.submitDeck(sessionPlayerMap.get(sessionId), deck);
match.submitDeck(playerId, deck);
}
else {
TournamentManager.getInstance().submitDeck(tournament.getId(), sessionId, deck);
TournamentManager.getInstance().submitDeck(tournament.getId(), playerId, deck);
}
}
public boolean watchTable(UUID sessionId) {
public boolean watchTable(String sessionId) {
if (table.getState() != TableState.DUELING) {
return false;
}
@ -213,11 +217,11 @@ public class TableController {
return true;
}
public boolean replayTable(UUID sessionId) {
public boolean replayTable(String sessionId) {
if (table.getState() != TableState.FINISHED) {
return false;
}
ReplayManager.getInstance().replayGame(sessionId, table.getId());
ReplayManager.getInstance().replayGame(table.getId(), sessionId);
return true;
}
@ -233,18 +237,18 @@ public class TableController {
return player;
}
public synchronized void leaveTable(UUID sessionId) {
public synchronized void leaveTable(String sessionId) {
if (table.getState() == TableState.WAITING || table.getState() == TableState.STARTING)
table.leaveTable(sessionPlayerMap.get(sessionId));
}
public synchronized void startMatch(UUID sessionId) {
public synchronized void startMatch(String sessionId) {
if (sessionId.equals(this.sessionId)) {
startMatch();
}
}
public synchronized void startChallenge(UUID sessionId, UUID challengeId) {
public synchronized void startChallenge(String sessionId, UUID challengeId) {
if (sessionId.equals(this.sessionId)) {
try {
match.startMatch();
@ -256,7 +260,7 @@ public class TableController {
GameManager.getInstance().createGameSession(match.getGame(), sessionPlayerMap, table.getId(), null);
ChallengeManager.getInstance().prepareChallenge(getPlayerId(), match);
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
sessionManager.getSession(entry.getKey()).gameStarted(match.getGame().getId(), entry.getValue());
}
} catch (GameException ex) {
@ -267,7 +271,7 @@ public class TableController {
private UUID getPlayerId() throws GameException {
UUID playerId = null;
for (Entry<UUID, UUID> entry : sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry : sessionPlayerMap.entrySet()) {
playerId = entry.getValue();
break;
}
@ -294,7 +298,7 @@ public class TableController {
table.initGame();
GameManager.getInstance().createGameSession(match.getGame(), sessionPlayerMap, table.getId(), choosingPlayerId);
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
Session session = sessionManager.getSession(entry.getKey());
if (session != null) {
session.gameStarted(match.getGame().getId(), entry.getValue());
@ -314,12 +318,12 @@ public class TableController {
}
}
public synchronized void startTournament(UUID sessionId) {
public synchronized void startTournament(String sessionId) {
try {
if (sessionId.equals(this.sessionId) && table.getState() == TableState.STARTING) {
TournamentManager.getInstance().createTournamentSession(tournament, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
Session session = sessionManager.getSession(entry.getKey());
session.tournamentStarted(tournament.getId(), entry.getValue());
}
@ -336,14 +340,14 @@ public class TableController {
table.initDraft();
DraftManager.getInstance().createDraftSession(draft, sessionPlayerMap, table.getId());
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
sessionManager.getSession(entry.getKey()).draftStarted(draft.getId(), entry.getValue());
}
}
private void sideboard(UUID playerId, Deck deck, int timeout) throws MageException {
SessionManager sessionManager = SessionManager.getInstance();
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
if (entry.getValue().equals(playerId)) {
sessionManager.getSession(entry.getKey()).sideboard(deck, table.getId(), timeout);
break;
@ -395,7 +399,7 @@ public class TableController {
}
}
public boolean isOwner(UUID sessionId) {
public boolean isOwner(String sessionId) {
return sessionId.equals(this.sessionId);
}

34
Mage.Server/src/main/java/mage/server/TableManager.java
View file

@ -60,7 +60,7 @@ public class TableManager {
return INSTANCE;
}
public Table createTable(UUID roomId, UUID sessionId, MatchOptions options) {
public Table createTable(UUID roomId, String sessionId, MatchOptions options) {
TableController tableController = new TableController(roomId, sessionId, options);
controllers.put(tableController.getTable().getId(), tableController);
tables.put(tableController.getTable().getId(), tableController.getTable());
@ -68,13 +68,13 @@ public class TableManager {
}
public Table createTable(UUID roomId, MatchOptions options) {
TableController tableController = new TableController(roomId, UUID.randomUUID(), options);
TableController tableController = new TableController(roomId, UUID.randomUUID().toString(), options);
controllers.put(tableController.getTable().getId(), tableController);
tables.put(tableController.getTable().getId(), tableController.getTable());
return tableController.getTable();
}
public Table createTournamentTable(UUID roomId, UUID sessionId, TournamentOptions options) {
public Table createTournamentTable(UUID roomId, String sessionId, TournamentOptions options) {
TableController tableController = new TableController(roomId, sessionId, options);
controllers.put(tableController.getTable().getId(), tableController);
tables.put(tableController.getTable().getId(), tableController.getTable());
@ -95,35 +95,35 @@ public class TableManager {
return tables.values();
}
public boolean joinTable(UUID sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
public boolean joinTable(String sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
if (controllers.containsKey(tableId))
return controllers.get(tableId).joinTable(sessionId, name, playerType, skill, deckList);
return false;
}
public boolean joinTournament(UUID sessionId, UUID tableId, String name, String playerType, int skill) throws GameException {
public boolean joinTournament(String sessionId, UUID tableId, String name, String playerType, int skill) throws GameException {
if (controllers.containsKey(tableId))
return controllers.get(tableId).joinTournament(sessionId, name, playerType, skill);
return false;
}
public boolean submitDeck(UUID sessionId, UUID tableId, DeckCardLists deckList) throws MageException {
public boolean submitDeck(String sessionId, UUID tableId, DeckCardLists deckList) throws MageException {
if (controllers.containsKey(tableId))
return controllers.get(tableId).submitDeck(sessionId, deckList);
return false;
}
public void removeSession(UUID sessionId) {
public void removeSession(String sessionId) {
// TODO: search through tables and remove session
}
public boolean isTableOwner(UUID tableId, UUID sessionId) {
public boolean isTableOwner(UUID tableId, String sessionId) {
if (controllers.containsKey(tableId))
return controllers.get(tableId).isOwner(sessionId);
return false;
}
public boolean removeTable(UUID sessionId, UUID tableId) {
public boolean removeTable(String sessionId, UUID tableId) {
if (isTableOwner(tableId, sessionId) || SessionManager.getInstance().isAdmin(sessionId)) {
removeTable(tableId);
return true;
@ -131,7 +131,7 @@ public class TableManager {
return false;
}
public void leaveTable(UUID sessionId, UUID tableId) {
public void leaveTable(String sessionId, UUID tableId) {
if (controllers.containsKey(tableId))
controllers.get(tableId).leaveTable(sessionId);
}
@ -142,7 +142,7 @@ public class TableManager {
return null;
}
public void startMatch(UUID sessionId, UUID roomId, UUID tableId) {
public void startMatch(String sessionId, UUID roomId, UUID tableId) {
if (controllers.containsKey(tableId))
controllers.get(tableId).startMatch(sessionId);
}
@ -152,12 +152,12 @@ public class TableManager {
controllers.get(tableId).startMatch();
}
public void startChallenge(UUID sessionId, UUID roomId, UUID tableId, UUID challengeId) {
public void startChallenge(String sessionId, UUID roomId, UUID tableId, UUID challengeId) {
if (controllers.containsKey(tableId))
controllers.get(tableId).startChallenge(sessionId, challengeId);
}
public void startTournament(UUID sessionId, UUID roomId, UUID tableId) {
public void startTournament(String sessionId, UUID roomId, UUID tableId) {
if (controllers.containsKey(tableId))
controllers.get(tableId).startTournament(sessionId);
}
@ -167,13 +167,13 @@ public class TableManager {
controllers.get(tableId).startDraft(draft);
}
public boolean watchTable(UUID sessionId, UUID tableId) {
public boolean watchTable(String sessionId, UUID tableId) {
if (controllers.containsKey(tableId))
return controllers.get(tableId).watchTable(sessionId);
return false;
}
public boolean replayTable(UUID sessionId, UUID tableId) {
public boolean replayTable(String sessionId, UUID tableId) {
if (controllers.containsKey(tableId))
return controllers.get(tableId).replayTable(sessionId);
return false;
@ -189,7 +189,7 @@ public class TableManager {
controllers.get(tableId).endDraft(draft);
}
public void swapSeats(UUID tableId, UUID sessionId, int seatNum1, int seatNum2) {
public void swapSeats(UUID tableId, String sessionId, int seatNum1, int seatNum2) {
if (controllers.containsKey(tableId) && isTableOwner(tableId, sessionId)) {
controllers.get(tableId).swapSeats(seatNum1, seatNum2);
}
@ -200,7 +200,7 @@ public class TableManager {
controllers.get(tableId).construct();
}
public void addPlayer(UUID sessionId, UUID tableId, Player player, String playerType, Deck deck) throws GameException {
public void addPlayer(String sessionId, UUID tableId, Player player, String playerType, Deck deck) throws GameException {
if (controllers.containsKey(tableId))
controllers.get(tableId).addPlayer(sessionId, player, playerType, deck);
}

16
Mage.Server/src/main/java/mage/server/draft/DraftController.java
View file

@ -56,12 +56,12 @@ public class DraftController {
public static final String INIT_FILE_PATH = "config" + File.separator + "init.txt";
private ConcurrentHashMap<UUID, DraftSession> draftSessions = new ConcurrentHashMap<UUID, DraftSession>();
private ConcurrentHashMap<UUID, UUID> sessionPlayerMap;
private ConcurrentHashMap<String, UUID> sessionPlayerMap;
private UUID draftSessionId;
private Draft draft;
private UUID tableId;
public DraftController(Draft draft, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId) {
public DraftController(Draft draft, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId) {
draftSessionId = UUID.randomUUID();
this.sessionPlayerMap = sessionPlayerMap;
this.draft = draft;
@ -116,11 +116,11 @@ public class DraftController {
checkStart();
}
private UUID getPlayerId(UUID sessionId) {
private UUID getPlayerId(String sessionId) {
return sessionPlayerMap.get(sessionId);
}
public void join(UUID sessionId) {
public void join(String sessionId) {
UUID playerId = sessionPlayerMap.get(sessionId);
DraftSession draftSession = new DraftSession(draft, sessionId, playerId);
draftSessions.put(playerId, draftSession);
@ -163,7 +163,7 @@ public class DraftController {
return true;
}
private void leave(UUID sessionId) {
private void leave(String sessionId) {
draft.leave(getPlayerId(sessionId));
}
@ -174,7 +174,7 @@ public class DraftController {
TableManager.getInstance().endDraft(tableId, draft);
}
public void kill(UUID sessionId) {
public void kill(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
draftSessions.get(sessionPlayerMap.get(sessionId)).setKilled();
draftSessions.remove(sessionPlayerMap.get(sessionId));
@ -183,7 +183,7 @@ public class DraftController {
}
}
public void timeout(UUID sessionId) {
public void timeout(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
draft.autoPick(sessionPlayerMap.get(sessionId));
}
@ -193,7 +193,7 @@ public class DraftController {
return this.draftSessionId;
}
public DraftPickView sendCardPick(UUID sessionId, UUID cardId) {
public DraftPickView sendCardPick(String sessionId, UUID cardId) {
if (draftSessions.get(sessionPlayerMap.get(sessionId)).sendCardPick(cardId)) {
return getDraftPickView(sessionPlayerMap.get(sessionId), 0);
}

12
Mage.Server/src/main/java/mage/server/draft/DraftManager.java
View file

@ -48,13 +48,13 @@ public class DraftManager {
private ConcurrentHashMap<UUID, DraftController> draftControllers = new ConcurrentHashMap<UUID, DraftController>();
public UUID createDraftSession(Draft draft, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId) {
public UUID createDraftSession(Draft draft, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId) {
DraftController draftController = new DraftController(draft, sessionPlayerMap, tableId);
draftControllers.put(draft.getId(), draftController);
return draftController.getSessionId();
}
public void joinDraft(UUID draftId, UUID sessionId) {
public void joinDraft(UUID draftId, String sessionId) {
draftControllers.get(draftId).join(sessionId);
}
@ -62,21 +62,21 @@ public class DraftManager {
draftControllers.remove(gameId);
}
public DraftPickView sendCardPick(UUID draftId, UUID sessionId, UUID cardId) {
public DraftPickView sendCardPick(UUID draftId, String sessionId, UUID cardId) {
return draftControllers.get(draftId).sendCardPick(sessionId, cardId);
}
public void removeSession(UUID sessionId) {
public void removeSession(String sessionId) {
for (DraftController controller: draftControllers.values()) {
controller.kill(sessionId);
}
}
public void kill(UUID draftId, UUID sessionId) {
public void kill(UUID draftId, String sessionId) {
draftControllers.get(draftId).kill(sessionId);
}
public void timeout(UUID gameId, UUID sessionId) {
public void timeout(UUID gameId, String sessionId) {
draftControllers.get(gameId).timeout(sessionId);
}

9
Mage.Server/src/main/java/mage/server/draft/DraftSession.java
View file

@ -32,12 +32,8 @@ import java.rmi.RemoteException;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import mage.game.draft.Draft;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -55,7 +51,7 @@ public class DraftSession {
protected final static Logger logger = Logger.getLogger(DraftSession.class);
protected UUID sessionId;
protected String sessionId;
protected UUID playerId;
protected Draft draft;
protected boolean killed = false;
@ -63,7 +59,7 @@ public class DraftSession {
private ScheduledFuture<?> futureTimeout;
protected static ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
public DraftSession(Draft draft, UUID sessionId, UUID playerId) {
public DraftSession(Draft draft, String sessionId, UUID playerId) {
this.sessionId = sessionId;
this.draft = draft;
this.playerId = playerId;
@ -143,7 +139,6 @@ public class DraftSession {
private synchronized void cancelTimeout() {
if (futureTimeout != null) {
futureTimeout.cancel(false);
((ThreadPoolExecutor)timeoutExecutor).getQueue().remove(futureTimeout);
}
}

37
Mage.Server/src/main/java/mage/server/game/GameController.java
View file

@ -81,8 +81,8 @@ public class GameController implements GameCallback {
public static final String INIT_FILE_PATH = "config" + File.separator + "init.txt";
private ConcurrentHashMap<UUID, GameSession> gameSessions = new ConcurrentHashMap<UUID, GameSession>();
private ConcurrentHashMap<UUID, GameWatcher> watchers = new ConcurrentHashMap<UUID, GameWatcher>();
private ConcurrentHashMap<UUID, UUID> sessionPlayerMap;
private ConcurrentHashMap<String, GameWatcher> watchers = new ConcurrentHashMap<String, GameWatcher>();
private ConcurrentHashMap<String, UUID> sessionPlayerMap;
private UUID gameSessionId;
private Game game;
private UUID chatId;
@ -91,7 +91,7 @@ public class GameController implements GameCallback {
private Future<?> gameFuture;
public GameController(Game game, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId, UUID choosingPlayerId) {
public GameController(Game game, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId, UUID choosingPlayerId) {
gameSessionId = UUID.randomUUID();
this.sessionPlayerMap = sessionPlayerMap;
chatId = ChatManager.getInstance().createChatSession();
@ -180,11 +180,11 @@ public class GameController implements GameCallback {
checkStart();
}
private UUID getPlayerId(UUID sessionId) {
private UUID getPlayerId(String sessionId) {
return sessionPlayerMap.get(sessionId);
}
public void join(UUID sessionId) {
public void join(String sessionId) {
UUID playerId = sessionPlayerMap.get(sessionId);
GameSession gameSession = new GameSession(game, sessionId, playerId);
gameSessions.put(playerId, gameSession);
@ -228,27 +228,27 @@ public class GameController implements GameCallback {
return true;
}
public void watch(UUID sessionId) {
public void watch(String sessionId) {
GameWatcher gameWatcher = new GameWatcher(sessionId, game.getId());
watchers.put(sessionId, gameWatcher);
gameWatcher.init(getGameView());
ChatManager.getInstance().broadcast(chatId, "", " has started watching", MessageColor.BLACK);
}
public void stopWatching(UUID sessionId) {
public void stopWatching(String sessionId) {
watchers.remove(sessionId);
ChatManager.getInstance().broadcast(chatId, "", " has stopped watching", MessageColor.BLACK);
}
public void concede(UUID sessionId) {
public void concede(String sessionId) {
game.concede(getPlayerId(sessionId));
}
private void leave(UUID sessionId) {
private void leave(String sessionId) {
game.quit(getPlayerId(sessionId));
}
public void cheat(UUID sessionId, UUID playerId, DeckCardLists deckList) {
public void cheat(String sessionId, UUID playerId, DeckCardLists deckList) {
Deck deck;
try {
deck = Deck.load(deckList);
@ -263,7 +263,7 @@ public class GameController implements GameCallback {
updateGame();
}
public boolean cheat(UUID sessionId, UUID playerId, String cardName) {
public boolean cheat(String sessionId, UUID playerId, String cardName) {
Card card = Sets.findCard(cardName, true);
if (card != null) {
Set<Card> cards = new HashSet<Card>();
@ -276,10 +276,9 @@ public class GameController implements GameCallback {
}
}
public void kill(UUID sessionId) {
public void kill(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
GameSession session = gameSessions.get(sessionPlayerMap.get(sessionId));
session.destroy();
gameSessions.get(sessionPlayerMap.get(sessionId)).setKilled();
gameSessions.remove(sessionPlayerMap.get(sessionId));
leave(sessionId);
sessionPlayerMap.remove(sessionId);
@ -290,7 +289,7 @@ public class GameController implements GameCallback {
}
}
public void timeout(UUID sessionId) {
public void timeout(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
ChatManager.getInstance().broadcast(chatId, "", game.getPlayer(sessionPlayerMap.get(sessionId)).getName() + " has timed out. Auto concede.", MessageColor.BLACK);
concede(sessionId);
@ -315,19 +314,19 @@ public class GameController implements GameCallback {
return chatId;
}
public void sendPlayerUUID(UUID sessionId, UUID data) {
public void sendPlayerUUID(String sessionId, UUID data) {
gameSessions.get(sessionPlayerMap.get(sessionId)).sendPlayerUUID(data);
}
public void sendPlayerString(UUID sessionId, String data) {
public void sendPlayerString(String sessionId, String data) {
gameSessions.get(sessionPlayerMap.get(sessionId)).sendPlayerString(data);
}
public void sendPlayerBoolean(UUID sessionId, Boolean data) {
public void sendPlayerBoolean(String sessionId, Boolean data) {
gameSessions.get(sessionPlayerMap.get(sessionId)).sendPlayerBoolean(data);
}
public void sendPlayerInteger(UUID sessionId, Integer data) {
public void sendPlayerInteger(String sessionId, Integer data) {
gameSessions.get(sessionPlayerMap.get(sessionId)).sendPlayerInteger(data);
}

30
Mage.Server/src/main/java/mage/server/game/GameManager.java
View file

@ -50,13 +50,13 @@ public class GameManager {
private ConcurrentHashMap<UUID, GameController> gameControllers = new ConcurrentHashMap<UUID, GameController>();
public UUID createGameSession(Game game, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId, UUID choosingPlayerId) {
public UUID createGameSession(Game game, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId, UUID choosingPlayerId) {
GameController gameController = new GameController(game, sessionPlayerMap, tableId, choosingPlayerId);
gameControllers.put(game.getId(), gameController);
return gameController.getSessionId();
}
public void joinGame(UUID gameId, UUID sessionId) {
public void joinGame(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).join(sessionId);
}
@ -71,64 +71,64 @@ public class GameManager {
return null;
}
public void sendPlayerUUID(UUID gameId, UUID sessionId, UUID data) {
public void sendPlayerUUID(UUID gameId, String sessionId, UUID data) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).sendPlayerUUID(sessionId, data);
}
public void sendPlayerString(UUID gameId, UUID sessionId, String data) {
public void sendPlayerString(UUID gameId, String sessionId, String data) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).sendPlayerString(sessionId, data);
}
public void sendPlayerBoolean(UUID gameId, UUID sessionId, Boolean data) {
public void sendPlayerBoolean(UUID gameId, String sessionId, Boolean data) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).sendPlayerBoolean(sessionId, data);
}
public void sendPlayerInteger(UUID gameId, UUID sessionId, Integer data) {
public void sendPlayerInteger(UUID gameId, String sessionId, Integer data) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).sendPlayerInteger(sessionId, data);
}
public void concedeGame(UUID gameId, UUID sessionId) {
public void concedeGame(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).concede(sessionId);
}
public void watchGame(UUID gameId, UUID sessionId) {
public void watchGame(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).watch(sessionId);
}
public void stopWatching(UUID gameId, UUID sessionId) {
public void stopWatching(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).stopWatching(sessionId);
}
public void removeSession(UUID sessionId) {
public void removeSession(String sessionId) {
for (GameController controller: gameControllers.values()) {
controller.kill(sessionId);
}
}
public void kill(UUID gameId, UUID sessionId) {
public void kill(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).kill(sessionId);
}
public void cheat(UUID gameId, UUID sessionId, UUID playerId, DeckCardLists deckList) {
public void cheat(UUID gameId, String sessionId, UUID playerId, DeckCardLists deckList) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).cheat(sessionId, playerId, deckList);
}
public boolean cheat(UUID gameId, UUID sessionId, UUID playerId, String cardName) {
public boolean cheat(UUID gameId, String sessionId, UUID playerId, String cardName) {
if (gameControllers.containsKey(gameId))
return gameControllers.get(gameId).cheat(sessionId, playerId, cardName);
return false;
}
public void timeout(UUID gameId, UUID sessionId) {
public void timeout(UUID gameId, String sessionId) {
if (gameControllers.containsKey(gameId))
gameControllers.get(gameId).timeout(sessionId);
}
@ -142,7 +142,7 @@ public class GameManager {
gameControllers.get(gameId).saveGame();
}
public GameView getGameView(UUID gameId, UUID sessionId, UUID playerId) {
public GameView getGameView(UUID gameId, String sessionId, UUID playerId) {
if (gameControllers.containsKey(gameId))
return gameControllers.get(gameId).getGameView(playerId);
return null;

12
Mage.Server/src/main/java/mage/server/game/GameSession.java
View file

@ -34,11 +34,8 @@ import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import mage.game.Game;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -61,7 +58,7 @@ public class GameSession extends GameWatcher {
private ScheduledFuture<?> futureTimeout;
protected static ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
public GameSession(Game game, UUID sessionId, UUID playerId) {
public GameSession(Game game, String sessionId, UUID playerId) {
super(sessionId, game.getId());
this.game = game;
this.playerId = playerId;
@ -173,8 +170,6 @@ public class GameSession extends GameWatcher {
private synchronized void cancelTimeout() {
if (futureTimeout != null) {
futureTimeout.cancel(false);
((ThreadPoolExecutor)timeoutExecutor).getQueue().remove(futureTimeout);
//System.out.println("tasks:"+ ((ThreadPoolExecutor)timeoutExecutor).getTaskCount());
}
}
@ -197,9 +192,4 @@ public class GameSession extends GameWatcher {
cancelTimeout();
game.getPlayer(playerId).setResponseInteger(data);
}
public void destroy() {
cancelTimeout();
setKilled();
}
}

7
Mage.Server/src/main/java/mage/server/game/GameWatcher.java
View file

@ -30,9 +30,6 @@ package mage.server.game;
import java.rmi.RemoteException;
import java.util.UUID;
import java.util.logging.Level;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -48,11 +45,11 @@ public class GameWatcher {
protected final static Logger logger = Logger.getLogger(GameWatcher.class);
protected UUID sessionId;
protected String sessionId;
protected UUID gameId;
protected boolean killed = false;
public GameWatcher(UUID sessionId, UUID gameId) {
public GameWatcher(String sessionId, UUID gameId) {
this.sessionId = sessionId;
this.gameId = gameId;
}

14
Mage.Server/src/main/java/mage/server/game/GamesRoom.java
View file

@ -45,14 +45,14 @@ import mage.view.TableView;
public interface GamesRoom extends Room {
public List<TableView> getTables();
public boolean joinTable(UUID sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException;
public boolean joinTournamentTable(UUID sessionId, UUID tableId, String name, String playerType, int skill) throws GameException;
public TableView createTable(UUID sessionId, MatchOptions options);
public TableView createTournamentTable(UUID sessionId, TournamentOptions options);
public void removeTable(UUID sessionId, UUID tableId);
public boolean joinTable(String sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException;
public boolean joinTournamentTable(String sessionId, UUID tableId, String name, String playerType, int skill) throws GameException;
public TableView createTable(String sessionId, MatchOptions options);
public TableView createTournamentTable(String sessionId, TournamentOptions options);
public void removeTable(String sessionId, UUID tableId);
public void removeTable(UUID tableId);
public TableView getTable(UUID tableId);
public void leaveTable(UUID sessionId, UUID tableId);
public boolean watchTable(UUID sessionId, UUID tableId) throws MageException;
public void leaveTable(String sessionId, UUID tableId);
public boolean watchTable(String sessionId, UUID tableId) throws MageException;
}

14
Mage.Server/src/main/java/mage/server/game/GamesRoomImpl.java
View file

@ -64,7 +64,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public boolean joinTable(UUID sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
public boolean joinTable(String sessionId, UUID tableId, String name, String playerType, int skill, DeckCardLists deckList) throws MageException {
if (tables.containsKey(tableId)) {
return TableManager.getInstance().joinTable(sessionId, tableId, name, playerType, skill, deckList);
} else {
@ -73,14 +73,14 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public TableView createTable(UUID sessionId, MatchOptions options) {
public TableView createTable(String sessionId, MatchOptions options) {
Table table = TableManager.getInstance().createTable(this.getRoomId(), sessionId, options);
tables.put(table.getId(), table);
return new TableView(table);
}
@Override
public boolean joinTournamentTable(UUID sessionId, UUID tableId, String name, String playerType, int skill) throws GameException {
public boolean joinTournamentTable(String sessionId, UUID tableId, String name, String playerType, int skill) throws GameException {
if (tables.containsKey(tableId)) {
return TableManager.getInstance().joinTournament(sessionId, tableId, name, playerType, skill);
} else {
@ -89,7 +89,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public TableView createTournamentTable(UUID sessionId, TournamentOptions options) {
public TableView createTournamentTable(String sessionId, TournamentOptions options) {
Table table = TableManager.getInstance().createTournamentTable(this.getRoomId(), sessionId, options);
tables.put(table.getId(), table);
return new TableView(table);
@ -103,7 +103,7 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public void removeTable(UUID sessionId, UUID tableId) {
public void removeTable(String sessionId, UUID tableId) {
tables.remove(tableId);
}
@ -115,12 +115,12 @@ public class GamesRoomImpl extends RoomImpl implements GamesRoom, Serializable {
}
@Override
public void leaveTable(UUID sessionId, UUID tableId) {
public void leaveTable(String sessionId, UUID tableId) {
TableManager.getInstance().leaveTable(sessionId, tableId);
}
@Override
public boolean watchTable(UUID sessionId, UUID tableId) throws MageException {
public boolean watchTable(String sessionId, UUID tableId) throws MageException {
return TableManager.getInstance().watchTable(sessionId, tableId);
}

10
Mage.Server/src/main/java/mage/server/game/ReplayManager.java
View file

@ -48,25 +48,25 @@ public class ReplayManager {
private ConcurrentHashMap<String, ReplaySession> replaySessions = new ConcurrentHashMap<String, ReplaySession>();
public void replayGame(UUID gameId, UUID sessionId) {
public void replayGame(UUID gameId, String sessionId) {
ReplaySession replaySession = new ReplaySession(gameId, sessionId);
replaySessions.put(gameId.toString() + sessionId.toString(), replaySession);
SessionManager.getInstance().getSession(sessionId).replayGame(gameId);
}
public void startReplay(UUID gameId, UUID sessionId) {
public void startReplay(UUID gameId, String sessionId) {
replaySessions.get(gameId.toString() + sessionId.toString()).replay();
}
public void stopReplay(UUID gameId, UUID sessionId) {
public void stopReplay(UUID gameId, String sessionId) {
replaySessions.get(gameId.toString() + sessionId.toString()).stop();
}
public void nextPlay(UUID gameId, UUID sessionId) {
public void nextPlay(UUID gameId, String sessionId) {
replaySessions.get(gameId.toString() + sessionId.toString()).next();
}
public void previousPlay(UUID gameId, UUID sessionId) {
public void previousPlay(UUID gameId, String sessionId) {
replaySessions.get(gameId.toString() + sessionId.toString()).previous();
}

6
Mage.Server/src/main/java/mage/server/game/ReplaySession.java
View file

@ -31,8 +31,6 @@ package mage.server.game;
import java.util.UUID;
import mage.game.Game;
import mage.game.GameState;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -47,9 +45,9 @@ public class ReplaySession implements GameCallback {
private final static Logger logger = Logger.getLogger(ReplaySession.class);
private GameReplay replay;
protected UUID sessionId;
protected String sessionId;
ReplaySession(UUID gameId, UUID sessionId) {
ReplaySession(UUID gameId, String sessionId) {
this.replay = new GameReplay(gameId);
this.sessionId = sessionId;
}

28
Mage.Server/src/main/java/mage/server/tournament/TournamentController.java
View file

@ -64,10 +64,10 @@ public class TournamentController {
private UUID chatId;
private UUID tableId;
private Tournament tournament;
private ConcurrentHashMap<UUID, UUID> sessionPlayerMap = new ConcurrentHashMap<UUID, UUID>();
private ConcurrentHashMap<String, UUID> sessionPlayerMap = new ConcurrentHashMap<String, UUID>();
private ConcurrentHashMap<UUID, TournamentSession> tournamentSessions = new ConcurrentHashMap<UUID, TournamentSession>();
public TournamentController(Tournament tournament, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId) {
public TournamentController(Tournament tournament, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId) {
sessionId = UUID.randomUUID();
this.sessionPlayerMap = sessionPlayerMap;
chatId = ChatManager.getInstance().createChatSession();
@ -128,7 +128,7 @@ public class TournamentController {
checkStart();
}
public synchronized void join(UUID sessionId) {
public synchronized void join(String sessionId) {
UUID playerId = sessionPlayerMap.get(sessionId);
TournamentSession tournamentSession = new TournamentSession(tournament, sessionId, tableId, playerId);
tournamentSessions.put(playerId, tournamentSession);
@ -196,16 +196,16 @@ public class TournamentController {
TableManager.getInstance().construct(tableId);
}
private void construct(UUID sessionId, Deck deck, int timeout) throws MageException {
if (tournamentSessions.containsKey(sessionId))
tournamentSessions.get(sessionId).construct(deck, timeout);
private void construct(UUID playerId, Deck deck, int timeout) throws MageException {
if (tournamentSessions.containsKey(playerId))
tournamentSessions.get(playerId).construct(deck, timeout);
}
public void submitDeck(UUID sessionId, Deck deck) {
tournamentSessions.get(sessionPlayerMap.get(sessionId)).submitDeck(deck);
public void submitDeck(UUID playerId, Deck deck) {
tournamentSessions.get(playerId).submitDeck(deck);
}
public void timeout(UUID sessionId) {
public void timeout(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
TournamentPlayer player = tournament.getPlayer(sessionPlayerMap.get(sessionId));
tournament.autoSubmit(sessionPlayerMap.get(sessionId), player.getDeck());
@ -220,7 +220,7 @@ public class TournamentController {
return chatId;
}
public void kill(UUID sessionId) {
public void kill(String sessionId) {
if (sessionPlayerMap.containsKey(sessionId)) {
tournamentSessions.get(sessionPlayerMap.get(sessionId)).setKilled();
tournamentSessions.remove(sessionPlayerMap.get(sessionId));
@ -229,16 +229,16 @@ public class TournamentController {
}
}
private void leave(UUID sessionId) {
private void leave(String sessionId) {
tournament.leave(getPlayerId(sessionId));
}
private UUID getPlayerId(UUID sessionId) {
private UUID getPlayerId(String sessionId) {
return sessionPlayerMap.get(sessionId);
}
private UUID getPlayerSessionId(UUID playerId) {
for (Entry<UUID, UUID> entry: sessionPlayerMap.entrySet()) {
private String getPlayerSessionId(UUID playerId) {
for (Entry<String, UUID> entry: sessionPlayerMap.entrySet()) {
if (entry.getValue().equals(playerId))
return entry.getKey();
}

12
Mage.Server/src/main/java/mage/server/tournament/TournamentManager.java
View file

@ -48,26 +48,26 @@ public class TournamentManager {
return INSTANCE;
}
public UUID createTournamentSession(Tournament tournament, ConcurrentHashMap<UUID, UUID> sessionPlayerMap, UUID tableId) {
public UUID createTournamentSession(Tournament tournament, ConcurrentHashMap<String, UUID> sessionPlayerMap, UUID tableId) {
TournamentController tournamentController = new TournamentController(tournament, sessionPlayerMap, tableId);
controllers.put(tournament.getId(), tournamentController);
return tournamentController.getSessionId();
}
public void joinTournament(UUID tournamentId, UUID sessionId) {
public void joinTournament(UUID tournamentId, String sessionId) {
controllers.get(tournamentId).join(sessionId);
}
public void kill(UUID tournamentId, UUID sessionId) {
public void kill(UUID tournamentId, String sessionId) {
controllers.get(tournamentId).kill(sessionId);
}
public void timeout(UUID tournamentId, UUID sessionId) {
public void timeout(UUID tournamentId, String sessionId) {
controllers.get(tournamentId).timeout(sessionId);
}
public void submitDeck(UUID tournamentId, UUID sessionId, Deck deck) {
controllers.get(tournamentId).submitDeck(sessionId, deck);
public void submitDeck(UUID tournamentId, UUID playerId, Deck deck) {
controllers.get(tournamentId).submitDeck(playerId, deck);
}
public TournamentView getTournamentView(UUID tournamentId) {

8
Mage.Server/src/main/java/mage/server/tournament/TournamentSession.java
View file

@ -32,13 +32,10 @@ import java.rmi.RemoteException;
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import mage.cards.decks.Deck;
import mage.game.tournament.Tournament;
import mage.MageException;
import mage.interfaces.callback.CallbackException;
import mage.interfaces.callback.ClientCallback;
import mage.server.Session;
import mage.server.SessionManager;
@ -53,7 +50,7 @@ import org.apache.log4j.Logger;
public class TournamentSession {
protected final static Logger logger = Logger.getLogger(TournamentSession.class);
protected UUID sessionId;
protected String sessionId;
protected UUID playerId;
protected UUID tableId;
protected Tournament tournament;
@ -62,7 +59,7 @@ public class TournamentSession {
private ScheduledFuture<?> futureTimeout;
protected static ScheduledExecutorService timeoutExecutor = ThreadExecutor.getInstance().getTimeoutExecutor();
public TournamentSession(Tournament tournament, UUID sessionId, UUID tableId, UUID playerId) {
public TournamentSession(Tournament tournament, String sessionId, UUID tableId, UUID playerId) {
this.sessionId = sessionId;
this.tournament = tournament;
this.playerId = playerId;
@ -147,7 +144,6 @@ public class TournamentSession {
private synchronized void cancelTimeout() {
if (futureTimeout != null) {
futureTimeout.cancel(false);
((ThreadPoolExecutor)timeoutExecutor).getQueue().remove(futureTimeout);
}
}