def activate_instance(request):
token = request.GET.get("token", "")
try:
encrypted_data = token.encode("ascii") # encrypted json containing the game id, the user login and a validity timestamp
(game_instance_id, creator_login, creator_email) = decode_game_activation_token(encrypted_data)
if not datamanager_administrator.game_instance_exists(game_instance_id):
datamanager_administrator.create_game_instance(game_instance_id=game_instance_id,
creator_login=creator_login,
creator_email=creator_email,
skip_randomizations=False)
else:
metadata = datamanager_administrator.get_game_instance_metadata_copy(game_instance_id) # shall NOT raise errors
if (metadata["creator_login"] != creator_login or metadata["creator_email"] != creator_email):
raise ValueError("Creator data doesn't match for game instance %(game_instance_id)s" % SDICT(game_instance_id=game_instance_id))
# we retrieve the datamanager whatever its possible maintenance status
dm = datamanager_administrator.retrieve_game_instance(game_instance_id, request=None, metadata_checker=lambda *args, **kwargs: True)
master_login = dm.get_global_parameter("master_login")
authentication_token = authentication.compute_enforced_login_token(game_instance_id=game_instance_id, login=master_login, is_observer=False)
session_token_display = urlencode({authentication.ENFORCED_SESSION_TICKET_NAME: authentication_token})
import pychronia_game.views
target_url = config.SITE_DOMAIN + reverse(pychronia_game.views.homepage, kwargs=dict(game_instance_id=game_instance_id, game_username=master_login))
target_url += "?" + session_token_display
content = _("In case you don't get properly redirected, please copy this link into our URL bar: %(target_url)s") % SDICT(target_url=target_url)
return HttpResponseRedirect(target_url, content=content)
except (ValueError, TypeError, LookupError, AttributeError, UnicodeError), e:
logging.warning("Game activation key not recognized : %s", token, exc_info=True)
return HttpResponseForbidden(_("Activation key not recognized"))
def activate_instance(request):
token = request.GET.get("token", "")
try:
encrypted_data = token.encode(
"ascii"
) # encrypted json containing the game id, the user login and a validity timestamp
(game_instance_id, creator_login,
creator_email) = decode_game_activation_token(encrypted_data)
if not datamanager_administrator.game_instance_exists(
game_instance_id):
datamanager_administrator.create_game_instance(
game_instance_id=game_instance_id,
creator_login=creator_login,
creator_email=creator_email,
skip_randomizations=False)
else:
metadata = datamanager_administrator.get_game_instance_metadata_copy(
game_instance_id) # shall NOT raise errors
if (metadata["creator_login"] != creator_login
or metadata["creator_email"] != creator_email):
raise ValueError(
"Creator data doesn't match for game instance %(game_instance_id)s"
% SDICT(game_instance_id=game_instance_id))
# we retrieve the datamanager whatever its possible maintenance status
dm = datamanager_administrator.retrieve_game_instance(
game_instance_id,
request=None,
metadata_checker=lambda *args, **kwargs: True)
master_login = dm.get_global_parameter("master_login")
authentication_token = authentication.compute_enforced_login_token(
game_instance_id=game_instance_id,
login=master_login,
is_observer=False)
session_token_display = urlencode({
authentication.ENFORCED_SESSION_TICKET_NAME:
authentication_token
})
import pychronia_game.views
target_url = config.SITE_DOMAIN + reverse(
pychronia_game.views.homepage,
kwargs=dict(game_instance_id=game_instance_id,
game_username=master_login))
target_url += "?" + session_token_display
content = _(
"In case you don't get properly redirected, please copy this link into our URL bar: %(target_url)s"
) % SDICT(target_url=target_url)
return HttpResponseRedirect(target_url, content=content)
except (ValueError, TypeError, LookupError, AttributeError,
UnicodeError) as e:
logging.warning("Game activation key not recognized : %s",
token,
exc_info=True)
return HttpResponseForbidden(_("Activation key not recognized"))
def execute():
try:
change_game_instance_status(DEMO_NAME, new_status="terminated")
delete_game_instance(DEMO_NAME)
except UsageError as e:
print("Exception swallowed:", e)
create_game_instance(game_instance_id=DEMO_NAME,
creator_login="******")
def setUp(self):
assert settings.DEBUG == True
django.utils.translation.activate("en") # to test for error messages, just in case...
reset_zodb_structure()
create_game_instance(game_instance_id=TEST_GAME_INSTANCE_ID,
creator_login="******",
skip_randomizations=True) # handy to test stuffs
try:
test_http_host = "localhost:80"
self.client = Client()
self.factory = RequestMock(HTTP_HOST=test_http_host)
self.request = self.factory.get(HOME_URL)
assert self.request.user
assert self.request.datamanager.user.datamanager.request # double linking
assert self.request.session
assert self.request._messages is not None
assert self.request.datamanager
# we mimic messages middleware
from django.contrib.messages.storage import default_storage
self.request._messages = default_storage(self.request)
self.dm = self.request.datamanager
assert self.dm.is_initialized
assert self.dm.connection
self.dm.clear_all_event_stats()
self.dm.check_database_coherency() # important
assert self.dm.get_event_count("BASE_CHECK_DB_COHERENCY_PUBLIC_CALLED") == 1 # no bypassing because of wrong override
self.dm.set_game_state(True)
self.dm.set_activated_game_views(self.dm.get_activable_views().keys()) # QUICK ACCESS FIXTURE
self.dm.clear_all_event_stats()
#self.default_player = self.dm.get_character_usernames()[0]
#self._set_user(self.TEST_LOGIN)
self.initial_msg_sent_length = len(self.dm.get_all_dispatched_messages())
self.initial_msg_queue_length = len(self.dm.get_all_queued_messages())
# comment this to have eclipse's autocompletion to work for datamanager anyway
self.dm = AutoCheckingDM(self.dm) # protection against uncommitted, pending changes
# NO NEED TO COMMIT - transaction watcher should do it all #
except Exception, e:
print(">>>>>>>>>", repr(e))
self.tearDown(check=False) # cleanup of connection
raise
os.remove(settings.ZODB_FILE)
import pychronia_game.models # initializes everything
from pychronia_game.datamanager.datamanager_administrator import reset_zodb_structure, create_game_instance
reset_zodb_structure()
if "use_fixture" in arguments:
skip_initializations = True
skip_randomizations = True
yaml_fixture = os.path.join(settings.GAME_FILES_ROOT, "script_fixtures", "_PROD_DUMP.yaml")
else:
skip_initializations = False
skip_randomizations = False
yaml_fixture = None
create_game_instance(game_instance_id="DEMO",
creator_login="******",
skip_initializations=skip_initializations,
yaml_fixture=yaml_fixture,
skip_randomizations=skip_randomizations)
elif "reset_django" in arguments:
if not settings.DEBUG:
raise RuntimeError("Can't reset django DB in non-DEBUG mode")
sys.argv[1:] = ("migrate --noinput --settings=%s" % settings_module).split()
execute_from_command_line()
sys.argv[1:] = ("flush --noinput --settings=%s" % settings_module).split()
execute_from_command_line()
elif "pack_file" in arguments:
from pychronia_game import utilities
assert utilities.config.ZODB_FILE
def setUp(self):
assert settings.DEBUG == True
django.utils.translation.activate(
"en") # to test for error messages, just in case...
reset_zodb_structure()
yaml_fixture = None
skip_initializations = False
if BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE:
print(
"[UNIT-TESTS] Using SHARED_DM_INITIAL_DATA_TREE to speed up the DM creation"
)
yaml_fixture = copy.deepcopy(
BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE)
skip_initializations = True
# FIXME - very heavy with loading + checking, we should do it only once and copy/paste dm.data tree.
create_game_instance(
game_instance_id=TEST_GAME_INSTANCE_ID,
creator_login="******",
skip_randomizations=True, # handy to test stuffs
skip_initializations=skip_initializations,
skip_coherence_check=True,
yaml_fixture=yaml_fixture)
if not BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE:
# we cache the FIRST datamanager data, for reuse
initial_dm = retrieve_game_instance(
game_instance_id=TEST_GAME_INSTANCE_ID)
BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE = copy.deepcopy(
initial_dm.data)
try:
test_http_host = "localhost:80"
self.client = DJANGO_TEST_CLIENT
self.request_factory = RequestMock(HTTP_HOST=test_http_host,
session=self.client.session)
request = self.request_factory.get(HOME_URL)
# this request is empty, not gone through middlewares!
assert request.datamanager
assert request.session
assert request.session is not self.client.session, \
(request.session, self.client.session) # generated on demand
assert request.user.is_anonymous
self.request = request
self.dm = self.request.datamanager
assert self.dm.is_initialized
assert self.dm.connection
self.dm.clear_all_event_stats()
if not skip_initializations:
self.dm.check_database_coherence(
) # thus, only done for the first testcase
assert self.dm.get_event_count(
"BASE_CHECK_DB_COHERENCE_PUBLIC_CALLED"
) == 1 # no bypassing because of wrong override
self.dm.set_game_state(True)
self.dm.set_activated_game_views(
list(self.dm.get_activable_views().keys())
) # QUICK ACCESS FIXTURE
self.dm.clear_all_event_stats()
#self.default_player = self.dm.get_character_usernames()[0]
#self._set_user(self.TEST_LOGIN)
self.initial_msg_sent_length = len(
self.dm.get_all_dispatched_messages())
self.initial_msg_queue_length = len(
self.dm.get_all_queued_messages())
# comment this to have eclipse's autocompletion to work for datamanager anyway
self.dm = AutoCheckingDM(
self.dm) # protection against uncommitted, pending changes
assert object.__getattribute__(
self.dm, "_real_dm") == self.request.datamanager # WRAPPED
# NO NEED TO COMMIT - transaction watcher should do it all #
except Exception as e:
print(">>>>>>>>>", repr(e))
self.tearDown(check=False) # cleanup of connection
raise
def setUp(self):
assert settings.DEBUG == True
django.utils.translation.activate("en") # to test for error messages, just in case...
reset_zodb_structure()
yaml_fixture = None
skip_initializations = False
if BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE:
print ("[UNIT-TESTS] Using SHARED_DM_INITIAL_DATA_TREE to speed up the DM creation")
yaml_fixture = copy.deepcopy(BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE)
skip_initializations = True
# FIXME - very heavy with loading + checking, we should do it only once and copy/paste dm.data tree.
create_game_instance(game_instance_id=TEST_GAME_INSTANCE_ID,
creator_login="******",
skip_randomizations=True, # handy to test stuffs
skip_initializations=skip_initializations,
skip_coherence_check=True,
yaml_fixture=yaml_fixture)
if not BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE:
# we cache the FIRST datamanager data, for reuse
initial_dm = retrieve_game_instance(game_instance_id=TEST_GAME_INSTANCE_ID)
BaseGameTestCase.SHARED_DM_INITIAL_DATA_TREE = copy.deepcopy(initial_dm.data)
try:
test_http_host = "localhost:80"
self.client = Client()
self.factory = RequestMock(HTTP_HOST=test_http_host)
self.request = self.factory.get(HOME_URL)
assert self.request.user
assert self.request.datamanager.user.datamanager.request # double linking
assert self.request.session
assert self.request._messages is not None
assert self.request.datamanager
# we mimic messages middleware
from django.contrib.messages.storage import default_storage
self.request._messages = default_storage(self.request)
self.dm = self.request.datamanager
assert self.dm.is_initialized
assert self.dm.connection
self.dm.clear_all_event_stats()
if not skip_initializations:
self.dm.check_database_coherence() # thus, only done for the first testcase
assert self.dm.get_event_count("BASE_CHECK_DB_COHERENCE_PUBLIC_CALLED") == 1 # no bypassing because of wrong override
self.dm.set_game_state(True)
self.dm.set_activated_game_views(self.dm.get_activable_views().keys()) # QUICK ACCESS FIXTURE
self.dm.clear_all_event_stats()
#self.default_player = self.dm.get_character_usernames()[0]
#self._set_user(self.TEST_LOGIN)
self.initial_msg_sent_length = len(self.dm.get_all_dispatched_messages())
self.initial_msg_queue_length = len(self.dm.get_all_queued_messages())
# comment this to have eclipse's autocompletion to work for datamanager anyway
self.dm = AutoCheckingDM(self.dm) # protection against uncommitted, pending changes
# NO NEED TO COMMIT - transaction watcher should do it all #
except Exception, e:
print(">>>>>>>>>", repr(e))
self.tearDown(check=False) # cleanup of connection
raise
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import setup_pychronia_env
import pychronia_game.models # initializes everything
from pychronia_game.datamanager.datamanager_administrator import (
delete_game_instance,
create_game_instance,
change_game_instance_status,
UsageError,
)
DEMO_NAME = "DEMO"
def execute():
try:
change_game_instance_status(DEMO_NAME, new_status="terminated")
delete_game_instance(DEMO_NAME)
except UsageError, e:
print "Exception swallowed:", e
create_game_instance(game_instance_id=DEMO_NAME, creator_login="******")
if __name__ == "__main__":
execute()
def manage_instances(request):
session_token_display = None
game_creation_form = None
require_email = False # superuser does what he wants
try:
if request.method == "POST":
if request.POST.get("create_game_instance"):
game_creation_form = GameInstanceCreationForm(require_email=require_email, data=request.POST)
if game_creation_form.is_valid():
cleaned_data = game_creation_form.cleaned_data
game_instance_id = cleaned_data["game_instance_id"]
creator_login = cleaned_data["creator_login"]
creator_email = cleaned_data["creator_email"] or None
datamanager_administrator.create_game_instance(game_instance_id=game_instance_id,
creator_login=creator_login,
creator_email=creator_email,
skip_randomizations=False)
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' successfully created for '%(creator_login)s/%(creator_email)s'") %
SDICT(game_instance_id=game_instance_id, creator_login=creator_login, creator_email=creator_email))
game_creation_form = None
else:
messages.add_message(request, messages.ERROR, _(u"Invalid game creation form submitted."))
elif request.POST.get("lock_instance"):
game_instance_id = request.POST["lock_instance"]
maintenance_until = datetime.utcnow() + timedelta(minutes=GAME_INSTANCE_MAINTENANCE_LOCKING_DELAY_MN)
datamanager_administrator.change_game_instance_status(game_instance_id=game_instance_id, maintenance_until=maintenance_until)
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' successfully locked") % SDICT(game_instance_id=game_instance_id))
elif request.POST.get("unlock_instance"):
game_instance_id = request.POST["unlock_instance"]
datamanager_administrator.change_game_instance_status(game_instance_id=game_instance_id, maintenance_until=None) # removes maintenance
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' successfully unlocked") % SDICT(game_instance_id=game_instance_id))
elif request.POST.get("change_instance_status"):
game_instance_id = request.POST["change_instance_status"]
new_status = request.POST["new_status"]
datamanager_administrator.change_game_instance_status(game_instance_id=game_instance_id, new_status=new_status) # change status
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' status changed to '%(new_status)s'") % SDICT(game_instance_id=game_instance_id, new_status=new_status))
elif request.POST.get("delete_game_instance"):
game_instance_id = request.POST["delete_game_instance"]
datamanager_administrator.delete_game_instance(game_instance_id=game_instance_id)
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' was deleted") % SDICT(game_instance_id=game_instance_id))
elif request.POST.get("backup_game_instance"):
game_instance_id = request.POST["backup_game_instance"]
backup_comment = slugify(request.POST["backup_comment"].strip()) or None
datamanager_administrator.backup_game_instance_data(game_instance_id=game_instance_id, comment=backup_comment)
messages.add_message(request, messages.INFO, _(u"Game instance '%(game_instance_id)s' backup with comment '%(backup_comment)s' done") %
SDICT(game_instance_id=game_instance_id, backup_comment=(backup_comment or u"<empty>")))
elif request.POST.get("compute_enforced_session_ticket"):
game_instance_id = request.POST["game_instance_id"].strip() # manually entered
login = request.POST["login"].strip()
is_observer = bool(request.POST.get("is_observer"))
authentication_token = authentication.compute_enforced_login_token(game_instance_id=game_instance_id, login=login, is_observer=is_observer)
messages.add_message(request, messages.INFO, _(u"Auto-connection token for instance=%(game_instance_id)s, login=%(login)s and is_observer=%(is_observer)s is displayed below") %
SDICT(game_instance_id=game_instance_id, login=login, is_observer=is_observer))
session_token_display = urlencode({authentication.ENFORCED_SESSION_TICKET_NAME: authentication_token})
else:
raise ValueError(_("Unknown admin action"))
except Exception as e:
messages.add_message(request, messages.ERROR, _(u"Unexpected error: %s") % e)
instances_metadata = datamanager_administrator.get_all_instances_metadata()
for _meta in instances_metadata:
_activation_link = _build_activation_url(game_instance_id=_meta["instance_id"], creator_login=_meta["creator_login"], creator_email=_meta["creator_email"])
_meta["activation_link"] = _activation_link
return render(request,
"meta_administration/manage_instances.html",
{
'instances_metadata': instances_metadata, # enriched info
'utc_now': datetime.utcnow(),
'notifications': get_messages(request),
'possible_game_statuses': sorted(GAME_STATUSES),
'deletable_statuses': [GAME_STATUSES.terminated, GAME_STATUSES.aborted],
'game_creation_form': game_creation_form or GameInstanceCreationForm(require_email=require_email),
'session_token_display': session_token_display,
})
def manage_instances(request):
session_token_display = None
game_creation_form = None
require_email = False # superuser does what he wants
try:
if request.method == "POST":
if request.POST.get("create_game_instance"):
game_creation_form = GameInstanceCreationForm(
require_email=require_email, data=request.POST)
if game_creation_form.is_valid():
cleaned_data = game_creation_form.cleaned_data
game_instance_id = cleaned_data["game_instance_id"]
creator_login = cleaned_data["creator_login"]
creator_email = cleaned_data["creator_email"] or None
datamanager_administrator.create_game_instance(
game_instance_id=game_instance_id,
creator_login=creator_login,
creator_email=creator_email,
skip_randomizations=False)
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' successfully created for '%(creator_login)s/%(creator_email)s'"
) % SDICT(game_instance_id=game_instance_id,
creator_login=creator_login,
creator_email=creator_email))
game_creation_form = None
else:
messages.add_message(
request, messages.ERROR,
_("Invalid game creation form submitted."))
elif request.POST.get("lock_instance"):
game_instance_id = request.POST["lock_instance"]
maintenance_until = datetime.utcnow() + timedelta(
minutes=GAME_INSTANCE_MAINTENANCE_LOCKING_DELAY_MN)
datamanager_administrator.change_game_instance_status(
game_instance_id=game_instance_id,
maintenance_until=maintenance_until)
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' successfully locked"
) % SDICT(game_instance_id=game_instance_id))
elif request.POST.get("unlock_instance"):
game_instance_id = request.POST["unlock_instance"]
datamanager_administrator.change_game_instance_status(
game_instance_id=game_instance_id,
maintenance_until=None) # removes maintenance
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' successfully unlocked"
) % SDICT(game_instance_id=game_instance_id))
elif request.POST.get("change_instance_status"):
game_instance_id = request.POST["change_instance_status"]
new_status = request.POST["new_status"]
datamanager_administrator.change_game_instance_status(
game_instance_id=game_instance_id,
new_status=new_status) # change status
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' status changed to '%(new_status)s'"
) % SDICT(game_instance_id=game_instance_id,
new_status=new_status))
elif request.POST.get("delete_game_instance"):
game_instance_id = request.POST["delete_game_instance"]
datamanager_administrator.delete_game_instance(
game_instance_id=game_instance_id)
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' was deleted") %
SDICT(game_instance_id=game_instance_id))
elif request.POST.get("backup_game_instance"):
game_instance_id = request.POST["backup_game_instance"]
backup_comment = slugify(
request.POST["backup_comment"].strip()) or None
datamanager_administrator.backup_game_instance_data(
game_instance_id=game_instance_id, comment=backup_comment)
messages.add_message(
request, messages.INFO,
_("Game instance '%(game_instance_id)s' backup with comment '%(backup_comment)s' done"
) % SDICT(game_instance_id=game_instance_id,
backup_comment=(backup_comment or "<empty>")))
elif request.POST.get("compute_enforced_session_ticket"):
game_instance_id = request.POST["game_instance_id"].strip(
) # manually entered
login = request.POST["login"].strip()
is_observer = bool(request.POST.get("is_observer"))
authentication_token = authentication.compute_enforced_login_token(
game_instance_id=game_instance_id,
login=login,
is_observer=is_observer)
messages.add_message(
request, messages.INFO,
_("Auto-connection token for instance=%(game_instance_id)s, login=%(login)s and is_observer=%(is_observer)s is displayed below"
) % SDICT(game_instance_id=game_instance_id,
login=login,
is_observer=is_observer))
session_token_display = urlencode({
authentication.ENFORCED_SESSION_TICKET_NAME:
authentication_token
})
else:
raise ValueError(_("Unknown admin action"))
except Exception as e:
messages.add_message(request, messages.ERROR,
_("Unexpected error: %s") % e)
instances_metadata = datamanager_administrator.get_all_instances_metadata()
for _meta in instances_metadata:
_activation_link = _build_activation_url(
game_instance_id=_meta["instance_id"],
creator_login=_meta["creator_login"],
creator_email=_meta["creator_email"])
_meta["activation_link"] = _activation_link
return render(
request,
"meta_administration/manage_instances.html",
{
'instances_metadata':
instances_metadata, # enriched info
'utc_now':
datetime.utcnow(),
'notifications':
get_messages(request),
'possible_game_statuses':
sorted(GAME_STATUSES),
'deletable_statuses':
[GAME_STATUSES.terminated, GAME_STATUSES.aborted],
'game_creation_form':
game_creation_form
or GameInstanceCreationForm(require_email=require_email),
'session_token_display':
session_token_display,
})
from pychronia_game.datamanager.datamanager_administrator import reset_zodb_structure, create_game_instance
reset_zodb_structure()
if "use_fixture" in arguments:
skip_initializations = True
skip_randomizations = True
yaml_fixture = os.path.join(settings.GAME_FILES_ROOT,
"script_fixtures", "_PROD_DUMP.yaml")
else:
skip_initializations = False
skip_randomizations = False
yaml_fixture = None
create_game_instance(game_instance_id="DEMO",
creator_login="******",
skip_initializations=skip_initializations,
yaml_fixture=yaml_fixture,
skip_randomizations=skip_randomizations)
elif "reset_django" in arguments:
if not settings.DEBUG:
raise RuntimeError("Can't reset django DB in non-DEBUG mode")
sys.argv[1:] = ("migrate --noinput --settings=%s" %
settings_module).split()
execute_from_command_line()
sys.argv[1:] = ("flush --noinput --settings=%s" %
settings_module).split()
execute_from_command_line()
elif "pack_file" in arguments:
from pychronia_game import utilities
