def start_server(io_loop):
global _server
if _server is not None:
io_loop.stop()
_server = Server()
_server.start(port=MAIN_PORT, io_loop=io_loop)
def test_game_7_press():
""" Test a complete 7 players game with press """
_ = Server() # Initialize cache to prevent timeouts during tests
game_path = os.path.join(FILE_FOLDER_NAME, 'game_data_7_press.csv')
run_with_timeout(
lambda: run_game_data(7, ['IGNORE_ERRORS', 'POWER_CHOICE'], game_path),
60)
def test_game_history():
""" Test a complete 1 player game and validate the full history (except last phase) """
_ = Server() # Initialize cache to prevent timeouts during tests
game_path = os.path.join(FILE_FOLDER_NAME, 'game_data_1_history.csv')
run_with_timeout(
lambda: run_game_data(1, ['NO_PRESS', 'IGNORE_ERRORS', 'POWER_CHOICE'],
game_path), 60)
def test_game_1():
""" Test a complete 1 player game """
_ = Server() # Initialize cache to prevent timeouts during tests
game_path = os.path.join(FILE_FOLDER_NAME, 'game_data_1.csv')
run_with_timeout(
lambda: run_game_data(1, ['NO_PRESS', 'IGNORE_ERRORS', 'POWER_CHOICE'],
game_path), 60)
def test_game_reject_map():
""" Test a game where the client rejects the map """
_ = Server() # Initialize cache to prevent timeouts during tests
game_path = os.path.join(FILE_FOLDER_NAME, 'game_data_1_reject_map.csv')
run_with_timeout(
lambda: run_game_data(1, ['NO_PRESS', 'IGNORE_ERRORS', 'POWER_CHOICE'],
game_path), 60)
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <https://www.gnu.org/licenses/>.
# ==============================================================================
""" Small module script to quickly start a server with pretty log-printing.
You can stop the server with keyboard interruption (Ctrl+C). Usage:
python -m diplomacy.server.run # run on port 8432.
python -m diplomacy.server.run --port=<given port> # run on given port.
"""
import argparse
from diplomacy import Server
from diplomacy.utils import constants
PARSER = argparse.ArgumentParser(description='Run server.')
PARSER.add_argument('--port',
'-p',
type=int,
default=constants.DEFAULT_PORT,
help='run on the given port (default: %s)' %
constants.DEFAULT_PORT)
ARGS = PARSER.parse_args()
try:
Server().start(port=ARGS.port)
except KeyboardInterrupt:
print('Keyboard interruption.')
def run_game_data(nb_daide_clients, rules, csv_file):
""" Start a server and a client to test DAIDE communications
:param port: The port of the DAIDE server
:param csv_file: the csv file containing the list of DAIDE communications
"""
server = Server()
io_loop = IOLoop()
io_loop.make_current()
common.Tornado.stop_loop_on_callback_error(io_loop)
@gen.coroutine
def coroutine_func():
""" Concrete call to main function. """
port = random.randint(9000, 9999)
while is_port_opened(port, HOSTNAME):
port = random.randint(9000, 9999)
nb_human_players = 1 if nb_daide_clients < 7 else 0
server.start(port=port)
server_game = ServerGame(map_name='standard',
n_controls=nb_daide_clients +
nb_human_players,
rules=rules,
server=server)
# Register game on server.
game_id = server_game.game_id
server.add_new_game(server_game)
server.start_new_daide_server(game_id)
# Creating human player
human_username = '******'
human_password = '******'
# Creating bot player to play for dummy powers
bot_username = constants.PRIVATE_BOT_USERNAME
bot_password = constants.PRIVATE_BOT_PASSWORD
# Connecting
connection = yield connect(HOSTNAME, port)
human_channel = yield connection.authenticate(human_username,
human_password)
bot_channel = yield connection.authenticate(bot_username, bot_password)
# Joining human to game
channels = {BOT_KEYWORD: bot_channel}
if nb_human_players:
yield human_channel.join_game(game_id=game_id,
power_name='AUSTRIA')
channels['AUSTRIA'] = human_channel
comms_simulator = ClientsCommsSimulator(nb_daide_clients, csv_file,
game_id, channels)
yield comms_simulator.retrieve_game_port(HOSTNAME, port)
# done_future is only used to prevent pylint E1101 errors on daide_future
done_future = Future()
daide_future = comms_simulator.execute()
chain_future(daide_future, done_future)
for _ in range(3 + nb_daide_clients):
if done_future.done() or server_game.count_controlled_powers() >= (
nb_daide_clients + nb_human_players):
break
yield gen.sleep(2.5)
else:
raise TimeoutError()
# Waiting for process to finish
while not done_future.done() and server_game.status == strings.ACTIVE:
yield gen.sleep(2.5)
yield daide_future
try:
io_loop.run_sync(coroutine_func)
finally:
server.stop_daide_server(None)
if server.backend.http_server:
server.backend.http_server.stop()
io_loop.stop()
io_loop.clear_current()
io_loop.close()
server = None
Server.__cache__.clear()