def test_create(self):
r = ReceivedPayment(from_node_id="DEF",
task="xyz",
val=4,
expected_val=3131,
state="SOMESTATE")
self.assertEquals(r.save(force_insert=True), 1)
with self.assertRaises(IntegrityError):
ReceivedPayment.create(from_node_id="DEF",
task="xyz",
val=5,
expected_val=3132,
state="SOMESTATEX")
ReceivedPayment.create(from_node_id="DEF",
task="xyz2",
val=5,
expected_val=3132,
state="SOMESTATEX")
ReceivedPayment.create(from_node_id="DEF2",
task="xyz",
val=5,
expected_val=3132,
state="SOMESTATEX")
self.assertEqual(
3, len([payment for payment in ReceivedPayment.select()]))
def __create_new_income(self, task_id, node_id, value, expected_value,
state):
with db.transaction():
ReceivedPayment.create(from_node_id=node_id,
task=task_id,
val=value,
expected_val=expected_value,
state=state)
def __add_income(self, task_id, node_id, value, expected_value, state):
before = ReceivedPayment.get(self.__same_transaction(task_id, node_id))
query = ReceivedPayment.update(val=before.val + value,
expected_val=before.expected_val +
expected_value,
state=state,
modified_date=str(datetime.now()))
query = query.where(self.__same_transaction(task_id, node_id))
query.execute()
def __change_income(self, task_id, node_id, value, expected_value, state):
query = ReceivedPayment.update(val=value,
expected_val=expected_value,
state=state,
modified_date=str(datetime.now()))
query = query.where(self.__same_transaction(task_id, node_id))
query.execute()
def get_newest_incomes(self, num=30):
""" Return <num> recently modfified incomes
:param int num: number of payments to return
:return:
"""
query = ReceivedPayment.select().order_by(
ReceivedPayment.modified_date.desc()).limit(num)
return query.execute()
def change_state(self, task_id, from_node, state):
""" Change state of payment that node <from_node> should have made for computing task <task_id>
:param str task_id: computed task
:param str from_node: node whose payment's state we want to change
:param state: new state
"""
query = ReceivedPayment.update(state=state,
modified_date=str(datetime.now()))
query = query.where(self.__same_transaction(task_id, from_node))
query.execute()
def get_state(self, task_id, from_node):
""" Return state of an income received from <from_node> for computing task <task_id>
:param str task_id: computed task
:param str from_node: node who should pay for computed task
:return str|None: return state of a payment if it's exist in database, otherwise return None
"""
try:
return ReceivedPayment.select().where(
self.__same_transaction(task_id, from_node)).get().state
except ReceivedPayment.DoesNotExist:
return None
def get_income_value(self, task_id, node_id):
""" Retrieve information about recieved value and expected value of a payment that node should receive from
node_id for computing task_id. If payment for such task doesn't exists write warning and return (0.0, 0.0)
:param task_id: id of a task that current node computed for node_id
:param node_id: id of a node that should pay computation
:return int, int: received value, expected value
"""
try:
rp = ReceivedPayment.select(ReceivedPayment.val,
ReceivedPayment.expected_val).where(
self.__same_transaction(
task_id, node_id)).get()
return rp.val, rp.expected_val
except ReceivedPayment.DoesNotExist:
logger.warning("Can't get income value - payment does not exist")
return 0, 0
def get_awaiting():
query = ReceivedPayment.select().where(
ReceivedPayment.state == IncomesState.waiting)
query = query.order_by(ReceivedPayment.created_date.desc())
return query
def test_default_fields(self):
r = ReceivedPayment()
self.assertGreaterEqual(datetime.now(), r.created_date)
self.assertGreaterEqual(datetime.now(), r.modified_date)