def test_unexpected_calc_states(self):
import logging
from django.utils import timezone
from aiida.orm.calculation import Calculation
# Have to use this ugly way of importing because the django migration
# files start with numbers which are not a valid package name
state_change = __import__(
'aiida.backends.djsite.db.migrations.0002_db_state_change',
fromlist=['fix_calc_states'])
from aiida.common.datastructures import calc_states
from aiida.backends.djsite.db.models import DbCalcState, DbLog
from aiida.orm.calculation.job import JobCalculation
calc_params = {
'computer': self.computer,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
}
for state in ['NOTFOUND', 'UNDETERMINED']:
# Let's create a dummy job calculation
job = JobCalculation(**calc_params)
job.store()
# Now save the errant state
DbCalcState(dbnode=job.dbnode, state=state).save()
time_before_fix = timezone.now()
# Call the code that deals with updating these states
state_change.fix_calc_states(None, None)
current_state = job.get_state()
self.assertNotEqual(
current_state, state,
"Migration code failed to change removed state {}".format(
state))
self.assertEqual(
current_state, calc_states.FAILED,
"Migration code failed to set removed state {} to {}".format(
current_state, calc_states.FAILED))
result = DbLog.objects.filter(
objpk__exact=job.pk,
levelname__exact=logging.getLevelName(logging.WARNING),
time__gt=time_before_fix)
self.assertEquals(
len(result), 1,
"Couldn't find a warning message with the change "
"from {} to {}, or found too many: I got {} log "
"messages".format(state, calc_states.FAILED, len(result)))
def _set_state(self, state):
"""
Set the state of the calculation.
Set it in the DbCalcState to have also the uniqueness check.
Moreover (except for the IMPORTED state) also store in the 'state'
attribute, useful to know it also after importing, and for faster
querying.
.. todo:: Add further checks to enforce that the states are set
in order?
:param state: a string with the state. This must be a valid string,
from ``aiida.common.datastructures.calc_states``.
:raise: ModificationNotAllowed if the given state was already set.
"""
super(JobCalculation, self)._set_state(state)
from aiida.common.datastructures import sort_states
from aiida.backends.djsite.db.models import DbCalcState
if not self.is_stored:
raise ModificationNotAllowed("Cannot set the calculation state "
"before storing")
if state not in calc_states:
raise ValueError(
"'{}' is not a valid calculation status".format(state))
old_state = self.get_state()
if old_state:
state_sequence = [state, old_state]
# sort from new to old: if they are equal, then it is a valid
# advance in state (otherwise, we are going backwards...)
if sort_states(state_sequence) != state_sequence:
raise ModificationNotAllowed("Cannot change the state from {} "
"to {}".format(old_state, state))
try:
with transaction.atomic():
new_state = DbCalcState(dbnode=self.dbnode, state=state).save()
except IntegrityError:
raise ModificationNotAllowed(
"Calculation pk= {} already transited through "
"the state {}".format(self.pk, state))
# For non-imported states, also set in the attribute (so that, if we
# export, we can still see the original state the calculation had.
if state != calc_states.IMPORTED:
self._set_attr('state', state)
def test_unexpected_calc_states(self):
import logging
from django.utils import timezone
from aiida.orm.calculation import Calculation
# Have to use this ugly way of importing because the django migration
# files start with numbers which are not a valid package name
state_change = __import__(
'aiida.backends.djsite.db.migrations.0002_db_state_change',
fromlist=['fix_calc_states']
)
from aiida.common.datastructures import calc_states
from aiida.backends.djsite.db.models import DbCalcState, DbLog
from aiida.orm.calculation.job import JobCalculation
calc_params = {
'computer': self.computer,
'resources': {'num_machines': 1,
'num_mpiprocs_per_machine': 1}
}
for state in ['NOTFOUND', 'UNDETERMINED']:
# Let's create a dummy job calculation
job = JobCalculation(**calc_params)
job.store()
# Now save the errant state
DbCalcState(dbnode=job.dbnode, state=state).save()
time_before_fix = timezone.now()
# First of all, I re-enable logging in case it was disabled by
# mistake by a previous test (e.g. one that disables and reenables
# again, but that failed)
logging.disable(logging.NOTSET)
# Temporarily disable logging to the stream handler (i.e. screen)
# because otherwise fix_calc_states will print warnings
handler = next((h for h in logging.getLogger('aiida').handlers if
isinstance(h, logging.StreamHandler)), None)
if handler:
original_level = handler.level
handler.setLevel(logging.ERROR)
# Call the code that deals with updating these states
state_change.fix_calc_states(None, None)
if handler:
handler.setLevel(original_level)
current_state = job.get_state()
self.assertNotEqual(current_state, state,
"Migration code failed to change removed state {}".
format(state))
self.assertEqual(current_state, calc_states.FAILED,
"Migration code failed to set removed state {} to {}".
format(current_state, calc_states.FAILED))
result = DbLog.objects.filter(
objpk__exact=job.pk,
levelname__exact=logging.getLevelName(logging.WARNING),
time__gt=time_before_fix
)
self.assertEquals(len(result), 1,
"Couldn't find a warning message with the change "
"from {} to {}, or found too many: I got {} log "
"messages".format(state, calc_states.FAILED, len(result))
)