def run_test():
lhs = SingleSide()
rhs = SingleSide()
lhs_event = lhs.new_event()
rhs_event = rhs.new_event()
# make a change to lhs' number and try to update rhs' number.
# ensure they can both commit the change.
lhs.number.write_val(lhs_event,2)
serializabled = lhs.number.serializable_var_tuple_for_network(
'some_name',lhs_event)
waldoNetworkSerializer.deserialize_peered_object_into_variable(
rhs._host_uuid,serializabled,rhs_event,rhs.number)
if not lhs_event.hold_can_commit():
print '\nError: should be able to commit lhs.\n'
return False
lhs_event.complete_commit()
if not rhs_event.hold_can_commit():
print '\nError: should be able to commit rhs.\n'
return False
rhs_event.complete_commit()
# check that both sides have the new number
lhs_event = lhs.new_event()
rhs_event = rhs.new_event()
if lhs.number.get_val(lhs_event) != 2:
print '\nErr: for some reason, did not commit on lhs.\n'
return False
if rhs.number.get_val(rhs_event) != 2:
print '\nErr: for some reason, did not commit on rhs.\n'
return False
if not lhs_event.hold_can_commit():
print '\nError: should be able to commit lhs second time.\n'
return False
lhs_event.complete_commit()
if not rhs_event.hold_can_commit():
print '\nError: should be able to commit rhs second time.\n'
return False
rhs_event.complete_commit()
return True
def run_test():
lhs = SingleSide()
rhs = SingleSide()
# lhs_event = lhs.new_event()
rhs_event = rhs.new_event()
internal_list1, evt = create_waldo_list(lhs, [1, 2, 3])
internal_list2, evt = create_waldo_list(lhs, [4, 5, 6], evt)
internal_list3, evt = create_waldo_list(lhs, [7, 8, 9], evt)
lhs.map.get_val(evt).add_key(evt, 1, internal_list1)
lhs.map.get_val(evt).add_key(evt, 2, internal_list2)
lhs.map.get_val(evt).add_key(evt, 1, internal_list3)
# should produce:
# { 1: [7,8,9], 2: [4,5,6] }
serializabled = lhs.map.serializable_var_tuple_for_network("some_name", evt)
waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event, rhs.map)
if not evt.hold_can_commit():
print "\nError: should be able to commit lhs.\n"
return False
evt.complete_commit()
if not rhs_event.hold_can_commit():
print "\nError: should be able to commit rhs.\n"
return False
rhs_event.complete_commit()
# now check that cannot do operations in parallel that affect each
# other. lhs_event will read all values in the map (and ensure
# that they were set correctly from above). It also sets one
# value. "concurrently" rhs_event1 will delete a value from its
# map. similarly, rhs_event2 will try to apply the change made
# from lhs_event. Should either be able to commit
# {lhs_event,rhs_event2} or {rhs_event1}, but not both sets.
lhs_event = lhs.new_event()
rhs_event1 = rhs.new_event()
rhs_event2 = rhs.new_event()
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 1).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 7:
print "\nErr: did not get change from previous commit.\n"
return False
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 4:
print "\nErr: did not get change from previous commit 2.\n"
return False
lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).write_val_on_key(lhs_event, 0, 20)
serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event)
waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map)
rhs.map.get_val(rhs_event1).del_key_called(rhs_event1, 1)
if not rhs_event1.hold_can_commit():
print "\nError: should be able to commit delete"
return False
rhs_event1.complete_commit()
if rhs_event2.hold_can_commit():
err_msg = "\nError: should not be able to commit rhs's "
err_msg += "read+single write update after committed delete\n"
return False
rhs_event2.backout_commit()
lhs_event.hold_can_commit()
lhs_event.backout_commit()
# should produce:
# { 2: [4,5,6] }
# now check that can do operations in parallel that do not affect
# each other. lhs_event sets one value. "concurrently" rhs_event1
# deletes a different value from its map. rhs_event2 will try to
# apply the change made from lhs_event. Should either be able to
# commit all events. lhs_event2 will try to commit the change
# made by rhs_event1
lhs_event1 = lhs.new_event()
lhs_event2 = lhs.new_event()
rhs_event1 = rhs.new_event()
rhs_event2 = rhs.new_event()
lhs.map.get_val(lhs_event1).get_val_on_key(lhs_event1, 2).get_val(lhs_event1).write_val_on_key(lhs_event1, 1, 16)
rhs.map.get_val(rhs_event1).get_val_on_key(rhs_event1, 2).get_val(rhs_event1).del_key_called(rhs_event1, 2)
serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event1)
waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map)
serializabled = rhs.map.serializable_var_tuple_for_network("some_name", rhs_event1)
waldoNetworkSerializer.deserialize_peered_object_into_variable(lhs._host_uuid, serializabled, lhs_event2, lhs.map)
if not lhs_event1.hold_can_commit():
print "\nError: should be able to commit lhs's write.\n"
return False
lhs_event1.complete_commit()
if not rhs_event1.hold_can_commit():
print "\nError: should be able to commit rhs's delete.\n"
return False
rhs_event1.complete_commit()
if not rhs_event2.hold_can_commit():
print "\nError: rhs_evt1 and rhs_evt2 should be able to commit in parallel.\n"
return False
rhs_event2.complete_commit()
if not lhs_event2.hold_can_commit():
print "\nError: should be able to commit the rhs change on lhs2.\n"
return False
lhs_event2.complete_commit()
# should produce:
# { 2: [4,16] }
# check to ensure that both sides saw the changes from above
lhs_event = lhs.new_event()
rhs_event = rhs.new_event()
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 1) != 16:
print "\nError: lhs_event should have seen updated value of 16.\n"
return False
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_len(lhs_event) != 2:
print "\nError: lhs_event should know that it contains a list of length 2.\n"
return False
if rhs.map.get_val(rhs_event).get_val_on_key(rhs_event, 2).get_val(rhs_event).get_val_on_key(rhs_event, 1) != 16:
print "\nError: rhs_event should have seen updated value of 16.\n"
return False
if rhs.map.get_val(rhs_event).get_val_on_key(rhs_event, 2).get_val(rhs_event).get_len(rhs_event) != 2:
print "\nError: rhs_event should know that it contains a list of length 2.\n"
return False
# should produce:
# { 2: [4,16] }
# another check that can do operations in parallel. lhs_event
# will read all values in the map (and ensure that they were set
# correctly from above). It also sets one value. "concurrently"
# rhs_event1 will delete a value from its map. similarly,
# rhs_event2 will try to apply the change made from lhs_event.
# Should be able to commit {lhs_event, rhs_event2} and then
# {rhs_event1}.
lhs_event = lhs.new_event()
rhs_event1 = rhs.new_event()
rhs_event2 = rhs.new_event()
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 4:
print "\nErr: did not get change from previous commit.\n"
return False
if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 1) != 16:
print "\nErr: did not get change from previous commit 2.\n"
return False
lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).write_val_on_key(lhs_event, 1, 20)
serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event)
waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map)
int_l, evtl = create_waldo_list(rhs, [1, 2, 3])
if not evtl.hold_can_commit():
print "\nError: should be able to append to list"
return False
evtl.complete_commit()
rhs.map.get_val(rhs_event1).add_key(rhs_event1, 1, int_l)
if not rhs_event1.hold_can_commit():
print "\nError: should be able to commit add"
return False
rhs_event1.complete_commit()
if not rhs_event2.hold_can_commit():
err_msg = "\nError: should not be able to commit rhs's "
err_msg += "read+single write update in parallel with add\n"
return False
rhs_event2.complete_commit()
if not lhs_event.hold_can_commit():
err_msg = "\nError: should not be able to commit lhs's "
err_msg += "read+single write update in parallel with add\n"
return False
lhs_event.complete_commit()
return True
