10 """Fill IO files DB with proper file( path)s. Write process IO test string.
12 Ensure IO files directory at server/. Remove any old input file if found.
13 Set up new input file for reading, and new output file for writing. Start
14 output file with process hash line of format PID + " " + floated UNIX time
15 (io_db["teststring"]). Raise SystemExit if file is found at path of either
16 record or save file plus io_db["tmp_suffix"].
18 def detect_atomic_leftover(path, tmp_suffix):
19 path_tmp = path + tmp_suffix
20 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
21 "aborted previous attempt to write '" + path + "'. Aborting " \
22 "until matter is resolved by removing it from its current path."
23 if os.access(path_tmp, os.F_OK):
25 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
26 os.makedirs(io_db["path_server"], exist_ok=True)
27 io_db["file_out"] = open(io_db["path_out"], "w")
28 io_db["file_out"].write(io_db["teststring"] + "\n")
29 io_db["file_out"].flush()
30 if os.access(io_db["path_in"], os.F_OK):
31 os.remove(io_db["path_in"])
32 io_db["file_in"] = open(io_db["path_in"], "w")
33 io_db["file_in"].close()
34 io_db["file_in"] = open(io_db["path_in"], "r")
35 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
36 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
39 def cleanup_server_io():
40 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
41 def helper(file_key, path_key):
43 io_db[file_key].close()
44 if not io_db["kicked_by_rival"] \
45 and os.access(io_db[path_key], os.F_OK):
46 os.remove(io_db[path_key])
47 helper("file_out", "path_out")
48 helper("file_in", "path_in")
49 helper("file_worldstate", "path_worldstate")
50 if "file_record" in io_db:
51 io_db["file_record"].close()
54 def obey(command, prefix, replay=False, do_record=False):
55 """Call function from commands_db mapped to command's first token.
57 The command string is tokenized by shlex.split(comments=True). If replay is
58 set, a non-meta command from the commands_db merely triggers obey() on the
59 next command from the records file. If not, and do do_record is set,
60 non-meta commands are recorded via record(), and save_world() is called.
61 The prefix string is inserted into the server's input message between its
62 beginning 'input ' & ':'. All activity is preceded by a server_test() call.
65 print("input " + prefix + ": " + command)
67 tokens = shlex.split(command, comments=True)
68 except ValueError as err:
69 print("Can't tokenize command string: " + str(err) + ".")
71 if len(tokens) > 0 and tokens[0] in commands_db \
72 and len(tokens) == commands_db[tokens[0]][0] + 1:
73 if commands_db[tokens[0]][1]:
74 commands_db[tokens[0]][2]()
76 print("Due to replay mode, reading command as 'go on in record'.")
77 line = io_db["file_record"].readline()
79 obey(line.rstrip(), io_db["file_record"].prefix
80 + str(io_db["file_record"].line_n))
81 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
83 print("Reached end of record file.")
85 commands_db[tokens[0]][2](*tokens[1:])
90 print("Invalid command/argument, or bad number of tokens.")
93 def atomic_write(path, text, do_append=False):
94 """Atomic write of text to file at path, appended if do_append is set."""
95 path_tmp = path + io_db["tmp_suffix"]
99 if os.access(path, os.F_OK):
100 shutil.copyfile(path, path_tmp)
101 file = open(path_tmp, mode)
104 os.fsync(file.fileno())
106 if os.access(path, os.F_OK):
108 os.rename(path_tmp, path)
112 """Append command string plus newline to record file. (Atomic.)"""
113 # This misses some optimizations from the original record(), namely only
114 # finishing the atomic write with expensive flush() and fsync() every 15
115 # seconds unless explicitely forced. Implement as needed.
116 atomic_write(io_db["path_record"], command + "\n", do_append=True)
120 # Dummy for saving all commands to reconstruct current world state.
121 # Misses same optimizations as record() from the original record().
122 atomic_write(io_db["path_save"],
123 "PLAYER_TYPE " + str(world_db["PLAYER_TYPE"]) + "\n" +
124 "TURN " + str(world_db["TURN"]) + "\n" +
125 "SEED_RANDOMNESS " + str(world_db["SEED_RANDOMNESS"]) + "\n" +
126 "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n")
129 def obey_lines_in_file(path, name, do_record=False):
130 """Call obey() on each line of path's file, use name in input prefix."""
131 file = open(path, "r")
133 for line in file.readlines():
134 obey(line.rstrip(), name + "file line " + str(line_n),
140 def parse_command_line_arguments():
141 """Return settings values read from command line arguments."""
142 parser = argparse.ArgumentParser()
143 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
145 opts, unknown = parser.parse_known_args()
150 """Ensure valid server out file belonging to current process.
152 This is done by comparing io_db["teststring"] to what's found at the start
153 of the current file at io_db["path_out"]. On failure, set
154 io_db["kicked_by_rival"] and raise SystemExit.
156 if not os.access(io_db["path_out"], os.F_OK):
157 raise SystemExit("Server output file has disappeared.")
158 file = open(io_db["path_out"], "r")
159 test = file.readline().rstrip("\n")
161 if test != io_db["teststring"]:
162 io_db["kicked_by_rival"] = True
163 msg = "Server test string in server output file does not match. This" \
164 " indicates that the current server process has been " \
165 "superseded by another one."
166 raise SystemExit(msg)
170 """Return next newline-delimited command from server in file.
172 Keep building return string until a newline is encountered. Pause between
173 unsuccessful reads, and after too much waiting, run server_test().
180 add = io_db["file_in"].readline()
182 command = command + add
183 if len(command) > 0 and "\n" == command[-1]:
184 command = command[:-1]
187 time.sleep(wait_on_fail)
188 if now + max_wait < time.time():
195 """Replay game from record file.
197 Use opts.replay as breakpoint turn to which to replay automatically before
198 switching to manual input by non-meta commands in server input file
199 triggering further reads of record file. Ensure opts.replay is at least 1.
203 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
204 " (if so late a turn is to be found).")
205 if not os.access(io_db["path_record"], os.F_OK):
206 raise SystemExit("No record file found to replay.")
207 io_db["file_record"] = open(io_db["path_record"], "r")
208 io_db["file_record"].prefix = "record file line "
209 io_db["file_record"].line_n = 1
210 while world_db["TURN"] < opts.replay:
211 line = io_db["file_record"].readline()
214 obey(line.rstrip(), io_db["file_record"].prefix
215 + str(io_db["file_record"].line_n))
216 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
218 obey(read_command(), "in file", replay=True)
222 """Play game by server input file commands. Before, load save file found.
224 If no save file is found, a new world is generated from the commands in the
225 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
226 command and all that follow via the server input file.
228 if os.access(io_db["path_save"], os.F_OK):
229 obey_lines_in_file(io_db["path_save"], "save")
231 if not os.access(io_db["path_worldconf"], os.F_OK):
232 msg = "No world config file from which to start a new world."
233 raise SystemExit(msg)
234 obey_lines_in_file(io_db["path_worldconf"], "world config ",
236 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
238 obey(read_command(), "in file", do_record=True)
243 print("I'd (re-)make the map now, if only I knew how.")
246 def worlddb_value_setter(key, min, max):
247 """Generate: Set world_db[key] to int(val_string) if >= min and <= max."""
248 def func(val_string):
250 val = int(val_string)
251 if val < min or val > max:
255 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
261 """Send PONG line to server output file."""
262 io_db["file_out"].write("PONG\n")
263 io_db["file_out"].flush()
267 """Abort server process."""
268 raise SystemExit("received QUIT command")
271 def command_seedmap(seed_string):
272 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
273 worlddb_value_setter("SEED_MAP", 0, 4294967295)(seed_string)
277 def command_makeworld(seed_string):
279 worlddb_value_setter("SEED_MAP", 0, 4294967295)(seed_string)
280 worlddb_value_setter("SEED_RANDOMNESS", 0, 4294967295)(seed_string)
283 """Commands database.
285 Map command start tokens to ([0]) number of expected command arguments, ([1])
286 the command's meta-ness (i.e. is it to be written to the record file, is it to
287 be ignored in replay mode if read from server input file), and ([2]) a function
291 "QUIT": (0, True, command_quit),
292 "PING": (0, True, command_ping),
293 "MAKE_WORLD": (1, False, command_makeworld),
294 "SEED_MAP": (1, False, command_seedmap),
295 "SEED_RANDOMNESS": (1, False, worlddb_value_setter("SEED_RANDOMNESS", 0,
297 "TURN": (1, False, worlddb_value_setter("TURN", 0, 65535)),
298 "PLAYER_TYPE": (1, False, worlddb_value_setter("PLAYER_TYPE", 0, 255))
302 """World state database,"""
306 "SEED_RANDOMNESS": 0,
311 """File IO database."""
314 "path_record": "record",
315 "path_worldconf": "confserver/world",
316 "path_server": "server/",
317 "path_in": "server/in",
318 "path_out": "server/out",
319 "path_worldstate": "server/worldstate",
320 "tmp_suffix": "_tmp",
321 "kicked_by_rival": False
326 opts = parse_command_line_arguments()
328 # print("DUMMY: Run game.")
329 if None != opts.replay:
333 except SystemExit as exit:
334 print("ABORTING: " + exit.args[0])
336 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
340 # print("DUMMY: (Clean up C heap.)")