public static Game createGame(Round round, int counter) {
String gameName =
String.format("%s_%d", round.getLevel().getTournament().getTournamentName(), counter);
Game game = new Game();
game.setGameName(gameName);
game.setRound(round);
game.setState(GameState.boot_pending);
game.setStartTime(round.getStartTime());
game.setLocation(randomLocation(round));
game.setSimStartTime(randomSimStartTime(game.getLocation()));
game.setServerQueue(Utils.createQueueName());
game.setVisualizerQueue(Utils.createQueueName());
return game;
}
private static String randomSimStartTime(String locationString) {
Location location = Location.getLocationByName(locationString);
long dateTo = location.getDateTo().getTime();
long dateFrom = location.getDateFrom().getTime();
// Number of msecs in a year divided by 4
double gameLength = (3.1556926 * Math.pow(10, 10)) / 4;
// Max amount of time between the fromTime to the toTime to start a game
long msLength = (long) gameLength;
Date starting = new Date();
if ((dateTo - dateFrom) < msLength) {
// Use fromTime in all games in the round as the start time
starting.setTime(dateFrom);
} else {
long end = dateTo - msLength;
long startTime = (long) (Math.random() * (end - dateFrom) + dateFrom);
starting.setTime(startTime);
}
return Utils.dateToStringSmall(starting);
}
@Entity
@Table(name = "games")
public class Game implements Serializable {
private static Logger log = Utils.getLogger();
private static TournamentProperties properties = TournamentProperties.getProperties();
private Integer gameId = 0;
private String gameName;
private Round round;
private Machine machine = null;
private GameState state = GameState.boot_pending;
private Date startTime;
private Date readyTime;
private String serverQueue = "";
private String visualizerQueue = "";
private String location = "";
private String simStartTime;
private Integer gameLength = 0;
private Integer lastTick = 0;
private Integer urgency;
private Map<Integer, Agent> agentMap = new HashMap<>();
private Random random = new Random();
public Game() {}
public void delete(Session session) {
// Delete all agent belonging to this broker
for (Agent agent : agentMap.values()) {
session.delete(agent);
session.flush();
}
session.delete(this);
}
@Transient
public String getBrokersInGameString() {
StringBuilder result = new StringBuilder();
String prefix = "";
for (Agent agent : agentMap.values()) {
result.append(prefix).append(agent.getBroker().getBrokerName());
prefix = ", ";
}
return result.toString();
}
@Transient
@SuppressWarnings("unchecked")
public String getBrokerIdsInGameString() {
List<Agent> agents = new ArrayList(agentMap.values());
Collections.sort(agents, new Utils.agentIdComparator());
StringBuilder result = new StringBuilder();
String prefix = "";
for (Agent agent : agents) {
result.append(prefix).append(agent.getBroker().getBrokerId());
prefix = ", ";
}
return result.toString();
}
public void removeBootFile() {
String bootLocation = properties.getProperty("bootLocation") + gameId + "-boot.xml";
File f = new File(bootLocation);
if (!f.exists()) {
return;
}
if (!f.canWrite()) {
log.error("Write protected: " + bootLocation);
}
if (!f.delete()) {
log.error("Failed to delete : " + bootLocation);
}
}
public String startTimeUTC() {
return Utils.dateToStringFull(startTime);
}
public String readyTimeUTC() {
return Utils.dateToStringFull(readyTime);
}
@Transient
public int getSize() {
return agentMap.size();
}
// Computes a random game length as outlined in the game specification
public int computeGameLength() {
String p = round.getRoundName().toLowerCase().contains("test") ? "test" : "competition";
int minLength = properties.getPropertyInt(p + ".minimumTimeslotCount");
int expLength = properties.getPropertyInt(p + ".expectedTimeslotCount");
if (expLength == minLength) {
return minLength;
} else {
double roll = random.nextDouble();
// compute k = ln(1-roll)/ln(1-p) where p = 1/(exp-min)
double k = (Math.log(1.0 - roll) / Math.log(1.0 - 1.0 / (expLength - minLength + 1)));
return minLength + (int) Math.floor(k);
}
}
public String jenkinsMachineUrl() {
if (machine == null) {
return "";
}
return String.format(
"%scomputer/%s/", properties.getProperty("jenkins.location"), machine.getMachineName());
}
public void saveStandings() {
try {
int bootLength = properties.getPropertyInt("bootLength");
gameLength = MemStore.getGameLengths().get(gameId) - bootLength;
lastTick = Integer.parseInt(MemStore.getGameHeartbeats().get(gameId)[0]) - bootLength;
} catch (Exception ignored) {
}
}
private static String randomLocation(Round round) {
double randLocation = Math.random() * round.getLocationsList().size();
return round.getLocationsList().get((int) Math.floor(randLocation));
}
private static String randomSimStartTime(String locationString) {
Location location = Location.getLocationByName(locationString);
long dateTo = location.getDateTo().getTime();
long dateFrom = location.getDateFrom().getTime();
// Number of msecs in a year divided by 4
double gameLength = (3.1556926 * Math.pow(10, 10)) / 4;
// Max amount of time between the fromTime to the toTime to start a game
long msLength = (long) gameLength;
Date starting = new Date();
if ((dateTo - dateFrom) < msLength) {
// Use fromTime in all games in the round as the start time
starting.setTime(dateFrom);
} else {
long end = dateTo - msLength;
long startTime = (long) (Math.random() * (end - dateFrom) + dateFrom);
starting.setTime(startTime);
}
return Utils.dateToStringSmall(starting);
}
public static Game createGame(Round round, int counter) {
String gameName =
String.format("%s_%d", round.getLevel().getTournament().getTournamentName(), counter);
Game game = new Game();
game.setGameName(gameName);
game.setRound(round);
game.setState(GameState.boot_pending);
game.setStartTime(round.getStartTime());
game.setLocation(randomLocation(round));
game.setSimStartTime(randomSimStartTime(game.getLocation()));
game.setServerQueue(Utils.createQueueName());
game.setVisualizerQueue(Utils.createQueueName());
return game;
}
public static Game getGameFromId(int gameId) {
Game game = null;
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
game = getGame(session, gameId);
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
}
return game;
}
public static Game getGame(Session session, int gameId) {
Query query = session.createQuery(Constants.HQL.GET_GAME_BY_ID);
query.setInteger("gameId", gameId);
return (Game) query.uniqueResult();
}
// <editor-fold desc="Collections">
@OneToMany
@JoinColumn(name = "gameId")
@MapKey(name = "brokerId")
public Map<Integer, Agent> getAgentMap() {
return agentMap;
}
public void setAgentMap(Map<Integer, Agent> agentMap) {
this.agentMap = agentMap;
}
@SuppressWarnings("unchecked")
public static List<Game> getNotCompleteGamesList() {
List<Game> games = new ArrayList<Game>();
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Query query = session.createQuery(Constants.HQL.GET_GAMES_NOT_COMPLETE);
games = (List<Game>) query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
}
session.close();
return games;
}
@SuppressWarnings("unchecked")
public static List<Game> getCompleteGamesList() {
List<Game> games = new ArrayList<Game>();
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Query query = session.createQuery(Constants.HQL.GET_GAMES_COMPLETE);
games = (List<Game>) query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
}
session.close();
return games;
}
// </editor-fold>
// <editor-fold desc="Setter and getters">
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "gameId", unique = true, nullable = false)
public Integer getGameId() {
return gameId;
}
public void setGameId(Integer gameId) {
this.gameId = gameId;
}
@Column(name = "gameName")
public String getGameName() {
return gameName;
}
public void setGameName(String gameName) {
this.gameName = gameName;
}
@ManyToOne
@JoinColumn(name = "roundId")
public Round getRound() {
return round;
}
public void setRound(Round round) {
this.round = round;
}
@ManyToOne
@JoinColumn(name = "machineId")
public Machine getMachine() {
return machine;
}
public void setMachine(Machine machine) {
this.machine = machine;
}
@Column(name = "state", nullable = false)
@Enumerated(EnumType.STRING)
public GameState getState() {
return state;
}
public void setState(GameState state) {
this.state = state;
}
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "startTime")
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "readyTime")
public Date getReadyTime() {
return readyTime;
}
public void setReadyTime(Date readyTime) {
this.readyTime = readyTime;
}
@Column(name = "visualizerQueue")
public String getVisualizerQueue() {
return visualizerQueue;
}
public void setVisualizerQueue(String name) {
this.visualizerQueue = name;
}
@Column(name = "serverQueue")
public String getServerQueue() {
return serverQueue;
}
public void setServerQueue(String name) {
this.serverQueue = name;
}
@Column(name = "location")
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
@Column(name = "simStartDate")
public String getSimStartTime() {
return simStartTime;
}
public void setSimStartTime(String simStartTime) {
this.simStartTime = simStartTime;
}
@Column(name = "gameLength")
public Integer getGameLength() {
return gameLength;
}
public void setGameLength(Integer gameLength) {
this.gameLength = gameLength;
}
@Column(name = "lastTick")
public Integer getLastTick() {
return lastTick;
}
public void setLastTick(Integer lastTick) {
this.lastTick = lastTick;
}
@Transient
public Integer getUrgency() {
return urgency;
}
public void setUrgency(int urgency) {
this.urgency = urgency;
}
// </editor-fold>
// Used by timeline
@Override
public String toString() {
return gameId + " : " + getBrokerIdsInGameString();
}
}
public String readyTimeUTC() {
return Utils.dateToStringFull(readyTime);
}
public String startTimeUTC() {
return Utils.dateToStringFull(startTime);
}
@WebServlet(
description = "REST API for game servers",
urlPatterns = {"/serverInterface.jsp"})
public class RestServer extends HttpServlet {
private static Logger log = Utils.getLogger();
private static String responseType = "text/plain; charset=UTF-8";
private TournamentProperties properties = TournamentProperties.getProperties();
public RestServer() {
super();
}
protected synchronized void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException {
String result = handleGET(request);
writeResult(response, result);
}
protected synchronized void doPut(HttpServletRequest request, HttpServletResponse response)
throws IOException {
String result = handlePUT(request);
writeResult(response, result);
}
protected synchronized void doPost(HttpServletRequest request, HttpServletResponse response)
throws IOException {
String result = handlePOST(request);
writeResult(response, result);
}
private void writeResult(HttpServletResponse response, String result) throws IOException {
response.setContentType(responseType);
response.setContentLength(result.length());
PrintWriter out = response.getWriter();
out.print(result);
out.flush();
out.close();
}
private String handleGET(HttpServletRequest request) {
try {
String actionString = request.getParameter(Rest.REQ_PARAM_ACTION);
if (actionString.equalsIgnoreCase(Rest.REQ_PARAM_STATUS)) {
if (!MemStore.checkMachineAllowed(request.getRemoteAddr())) {
return "error";
}
return handleStatus(request);
} else if (actionString.equalsIgnoreCase(Rest.REQ_PARAM_BOOT)) {
return serveBoot(getGameId(request));
} else if (actionString.equalsIgnoreCase(Rest.REQ_PARAM_HEARTBEAT)) {
if (!MemStore.checkMachineAllowed(request.getRemoteAddr())) {
return "error";
}
return handleHeartBeat(request);
}
} catch (Exception ignored) {
}
return "error";
}
/** Handle 'PUT' to serverInterface.jsp, either boot.xml or (Boot|Sim) log */
private String handlePUT(HttpServletRequest request) {
if (!MemStore.checkMachineAllowed(request.getRemoteAddr())) {
return "error";
}
try {
String fileName = request.getParameter(Rest.REQ_PARAM_FILENAME);
log.info("Received a file " + fileName);
String logLoc =
fileName.endsWith("boot.xml")
? properties.getProperty("bootLocation")
: properties.getProperty("logLocation");
String pathString = logLoc + fileName;
// Write to file
InputStream is = request.getInputStream();
FileOutputStream fos = new FileOutputStream(pathString);
byte buf[] = new byte[1024];
int letti;
while ((letti = is.read(buf)) > 0) {
fos.write(buf, 0, letti);
}
is.close();
fos.close();
// If sim-logs received, extract end-of-game standings
new ParserSimlog(pathString).run();
// Create softlinks to named versions
String gameName = request.getParameter(Rest.REQ_PARAM_GAMENAME);
createSoftLinks(fileName, logLoc, gameName);
} catch (Exception e) {
return "error";
}
return "success";
}
/** Handle 'POST' to serverInterface.jsp, this is an end-of-game message */
private String handlePOST(HttpServletRequest request) {
if (!MemStore.checkMachineAllowed(request.getRemoteAddr())) {
return "error";
}
try {
String actionString = request.getParameter(Rest.REQ_PARAM_ACTION);
if (!actionString.equalsIgnoreCase(Rest.REQ_PARAM_GAMERESULTS)) {
log.debug("The message didn't have the right action-string!");
return "error";
}
int gameId = getGameId(request);
if (!(gameId > 0)) {
log.debug("The message didn't have a gameId!");
return "error";
}
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Game game = (Game) session.get(Game.class, gameId);
String standings = request.getParameter(Rest.REQ_PARAM_MESSAGE);
return new GameHandler(game).handleStandings(session, standings, true);
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
return "error";
} finally {
session.close();
}
} catch (Exception e) {
log.error("Something went wrong with receiving the POST message!");
log.error(e.getMessage());
return "error";
}
}
private String serveBoot(int gameId) {
StringBuilder result = new StringBuilder();
try {
// Determine boot-file location
String bootLocation = properties.getProperty("bootLocation") + "game-" + gameId + "-boot.xml";
// Read the file
FileInputStream fstream = new FileInputStream(bootLocation);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;
while ((strLine = br.readLine()) != null) {
result.append(strLine).append("\n");
}
// Close the streams
fstream.close();
in.close();
br.close();
} catch (Exception e) {
log.error(e.getMessage());
return "error";
}
return result.toString();
}
private String handleStatus(HttpServletRequest request) {
String statusString = request.getParameter(Rest.REQ_PARAM_STATUS);
int gameId = getGameId(request);
log.info(String.format("Received %s message from game: %s", statusString, gameId));
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Query query = session.createQuery(Constants.HQL.GET_GAME_BY_ID);
query.setInteger("gameId", gameId);
Game game = (Game) query.uniqueResult();
if (game == null) {
log.warn(
String.format(
"Trying to set status %s on non-existing " + "game : %s", statusString, gameId));
return "error";
}
new GameHandler(game).handleStatus(session, statusString);
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
return "error";
} finally {
session.close();
}
String gameLength = request.getParameter(Rest.REQ_PARAM_GAMELENGTH);
if (gameLength != null && transaction.wasCommitted()) {
log.info(String.format("Received gamelength %s for game %s", gameLength, gameId));
MemStore.addGameLength(gameId, gameLength);
}
return "success";
}
private String handleHeartBeat(HttpServletRequest request) {
int gameId;
// Write heartbeat + elapsed time to the MemStore
try {
String message = request.getParameter(Rest.REQ_PARAM_MESSAGE);
gameId = getGameId(request);
if (!(gameId > 0)) {
log.debug("The message didn't have a gameId!");
return "error";
}
MemStore.addGameHeartbeat(gameId, message);
long elapsedTime = Long.parseLong(request.getParameter(Rest.REQ_PARAM_ELAPSED_TIME));
if (elapsedTime > 0) {
MemStore.addElapsedTime(gameId, elapsedTime);
}
} catch (Exception e) {
e.printStackTrace();
return "error";
}
// Write heartbeat to the DB
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Game game = (Game) session.get(Game.class, gameId);
String standings = request.getParameter(Rest.REQ_PARAM_STANDINGS);
return new GameHandler(game).handleStandings(session, standings, false);
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
return "error";
} finally {
session.close();
}
}
private int getGameId(HttpServletRequest request) {
int gameId;
try {
gameId = Integer.parseInt(request.getParameter(Rest.REQ_PARAM_GAMEID));
} catch (Exception ignored) {
String niceName = request.getParameter(Rest.REQ_PARAM_GAMEID);
gameId = MemStore.getGameId(niceName);
}
return gameId;
}
private void createSoftLinks(String fileName, String logLoc, String gameName) {
String linkName;
if (fileName.endsWith("boot.xml")) {
linkName = String.format("%s%s.boot.xml", logLoc, gameName);
} else if (fileName.contains("boot")) {
linkName = String.format("%s%s.boot.tar.gz", logLoc, gameName);
} else {
linkName = String.format("%s%s.sim.tar.gz", logLoc, gameName);
}
try {
Path link = Paths.get(linkName);
Path target = Paths.get(fileName);
Files.createSymbolicLink(link, target);
} catch (FileAlreadyExistsException faee) {
// Ignored
} catch (IOException | UnsupportedOperationException e) {
e.printStackTrace();
}
}
}