class Coordinator():
_sync = {'commit': '1', 'set_cohorts': '2'}
_async = ['hello_world']
_ref = []
_parallel = []
def __init__(self):
self.cohort = None
self.abort = False
print 'hola que tal! init'
def set_cohorts(self,cohortlist):
self.amulti = AMulti(cohortlist)
print 'self.amulti', self.amulti
self.smulti = SMulti(self._atom, cohortlist)
print 'self.smulti', self.smulti
return True
def commit(self):
vote = COMMIT
votes = self.smulti.vote_request()
#print votes
if votes.__contains__(ABORT):
self.abort = True
self.final_decision()
print 'hola que tal!'
return True
def final_decision(self):
if self.abort==True:
self.amulti.global_abort()
else:
self.amulti.global_commit()
class Server(object):
_sync = {}
_async = ['add_actors', 'add', 'sync_add','print_references']
_ref = ['add_actors']
_parallel = []
def add_actors(self, list_actors):
self.amulti = AMulti(list_actors)
self.smulti = SMulti(list_actors, self._atom)
def add(self, x, y):
self.amulti.add(x, y)
def sync_add(self, x, y):
result = self.smulti.sync_add(x, y)
print 'siiiiiiiiiiiiiiiiiiiiii', result
def print_references(self):
print self.smulti.get_reference()
def __init__(self, time, retries, owner, actors = []):
self.owner = owner
self.s_actor = new_supervisor(self.owner.aref)
self.actors = {}
self.retries = {}
self.max_retries = retries
self.multiActors = SMulti( self.s_actor, actors)
self.add_actors(actors)
interval(time, self.ask_actors)
class Server(object):
_sync = {'add_actors':'20'}
_async = ['add', 'sync_add','print_references']
_ref = ['add_actors']
_parallel = []
def add_actors(self, list_actors):
self.supervisor = Supervisor(5, 3, self._atom, list_actors)
self.amulti = AMulti(list_actors)
self.smulti = SMulti(self._atom, list_actors)
return True
def add(self, x, y):
self.amulti.add(x, y)
def sync_add(self, x, y):
result = self.smulti.sync_add(x, y)
print result.values()
def print_references(self):
print self.smulti.get_reference().values()
def failure_detect(self, from_actor):
print 'failure', from_actor
class Server(object):
_sync = {}
_async = ['add_actors', 'add', 'sync_add','print_references']
_ref = ['add_actors']
_parallel = []
def add_actors(self, list_actors):
print list_actors
self.amulti = AMulti(list_actors)
self.smulti = SMulti(self._atom, list_actors)
self.list_actors = list_actors
def add(self, x, y):
self.amulti.add(x, y)
def sync_add(self, x, y):
result = self.smulti.sync_add(x, y)
print result.values()
def print_references(self):
for a in range(16):
print 'hola'
print self.smulti.get_reference().keys()
class Supervisor():
def __init__(self, time, retries, owner, actors = []):
self.owner = owner
self.s_actor = new_supervisor(self.owner.aref)
self.actors = {}
self.retries = {}
self.max_retries = retries
self.multiActors = SMulti( self.s_actor, actors)
self.add_actors(actors)
interval(time, self.ask_actors)
#timer to indicate the frequency to ask to actors
def add_actor(self, actor):
self.actors[actor.get_aref()] = actor
self.retries[actor.get_aref()] = 0
self.multiActors.attach(actor)
def add_actors(self, actors):
for actor in actors:
self.add_actor(actor)
def ask_actors(self):
try:
result = self.multiActors.keep_alive()
for k in result.keys():
self.retries[k] = 0
except:
for key in self.actors.keys():
self.retries[key] +=1
if self.retries[key] > self.max_retries:
self.owner.failure_detect(self.actors[key])
self.retries[key] = 0
else:
if len(result.keys()) != len(self.actors.keys()):
fault_list_keys = result.keys() - self.actors.keys()
for key in fault_list_keys:
self.retries[key] += 1
if (self.retries[key] > self.max_retries):
self.owner.failure_detect(self.actors[key])
self.retries[key] = 0
def set_multi(self, list_acceptors):
self.list_acceptors = list_acceptors
self.set_server_dict()
self.amulti = AMulti(self.list_acceptors)
self.smulti = SMulti(self.proxy, self.list_acceptors)
class Server(object):
_sync = {'is_alive':'1', 'prepare':'2', 'get_accepted_values':'2'}
_async = ['set_multi', 'set_interval','promise', 'set_proposal', 'onPrepare',
'accepted', 'accept', 'set_leader', 'heartbeat' ]
_ref = ['set_multi', 'onPrepare', 'accept', 'accepted', 'set_proposal']
_parallel = ['heartbeat']
def __init__(self, quorum_size):
self.quorum_size = quorum_size
self.retries = 0
self.last_log_index = None
self.min_proposal = None
self.first_unchosen_index = 0
self.accepted_value = {}
self.accepted_proposal = {}
self.index = 0
self.max_round = 0
self.leader = False
self.highestInstance = 0
self.prepared = False
self.next_index = self.index + 1
self.leader_proxy = None
self.proposed_value = {}
self.last_accepted_id = {}
self.next_proposal_number = 1 # [1]*self.max_round
self.num_noMoreAccepted = {}
self.accepted_rcvd = set()
self.server_dict = {}
def set_leader(self):
self.leader = True
def set_server_dict(self):
'''Dict <key, value> --> <server_id, server_reference>'''
for acceptor in self.list_acceptors:
self.server_dict[acceptor.get_id()] = acceptor
def set_multi(self, list_acceptors):
self.list_acceptors = list_acceptors
self.set_server_dict()
self.amulti = AMulti(self.list_acceptors)
self.smulti = SMulti(self.proxy, self.list_acceptors)
def get_accepted_values(self):
return self.accepted_value.values()
'''Leader Election'''
def heartbeat(self):
change_leader = True
list_ids = self.smulti.is_alive()
max_id = max(list_ids.values())
if max_id > self.id:
change_leader = False
self.leader_proxy = self.server_dict[max_id]
if change_leader:
self.retries +=1
else:
self.retries = 0
if self.retries >= 2:
self.leader = True
def is_alive(self):
return self.id
def set_proposal(self, value, client):
'''
Sets the proposal value for this node if this node is not the leader, it redirect the value
to actual leader.
'''
self.current_client = client
if not self.leader:
if not self.leader_proxy:
return False
return self.leader_proxy.set_proposal(value, client)
else:
self.index = self.highestInstance
self.proposed_value[self.index]= value
self.highestInstance += 1
self.last_accepted_id[self.index] = 0
self.num_noMoreAccepted[self.index] = 0
self.prepare()
'''
Acceptor
'''
def onPrepare(self, proposer, n, index):
'''
Called when a Prepare message is received from a Proposer
'''
if n >= self.min_proposal:
# Duplicate prepare message
self.min_proposal = n
try:
proposer.promise(self.id, self.accepted_proposal[index], self.accepted_value[index], True)
except:
proposer.promise(self.id, None, None, True)
def accept(self, proxy, index, n, v, first_unchosen_index):
'''
Called when an Accept! message is received from a Proposer
'''
if n >= self.min_proposal:
self.accepted_proposal[index] = n
self.min_proposal = n
self.accepted_value[index] = v
'''send accepted to all learners!! '''
# self.amulti.accepted(self.id, proposal_id, self.accepted_value)
for i in range(1, first_unchosen_index-1):
if self.accepted_proposal[i] == n:
self.accepted_proposal[i] = 0
'''revisar returns'''
# print proxy, proxy.get_id()
proxy.accepted(self.proxy, self.min_proposal, self.first_unchosen_index)
# '''send accepted to all learners!! '''
# self.amulti.accepted(self.id, proposal_id, self.accepted_value)
def success(self, index, v):
self.accepted_value[index] = v
self.accepted_proposal[index] = 0
'''revisar returns'''
return self.firstUnchosenIndex
'''
Proposer
'''
def prepare(self):
'''
Sends a prepare request to all Acceptors as the first step in attempting to
acquire leadership of the Paxos instance.
'''
if self.prepared:
try:
self.accepted_rcvd = set()
self.amulti.accept(self.proxy, self.index, self.min_proposal, self.proposed_value[self.index], self.first_unchosen_index)
except:
return False
else:
self.promises_rcvd = set()
self.min_proposal = ProposalID(self.next_proposal_number, self.id)
self.next_proposal_number += 1
#multi to all acceptors!!
self.amulti.onPrepare(self.proxy, self.min_proposal, self.index)
return True
def promise(self, from_uid, accepted_proposal, accepted_value, noMoreAccepted):
#if accepted_proposal
#si el maxim accepted_proposal != 0
'''
Called when a Promise message is received from an Acceptor
'''
# Ignore the message if it's for an old proposal or we have already received
# a response from this Acceptor
#if accepted_proposal != self.accepted_proposal[self.index] or from_uid in self.promises_rcvd:
# return None
self.promises_rcvd.add( from_uid )
#si el maxim accepted_proposal != 0
print 'last_accepted_id', self.last_accepted_id, 'index', self.index
if accepted_proposal > self.last_accepted_id[self.index]:
self.last_accepted_id[self.index] = accepted_proposal
# If the Acceptor has already accepted a value, we MUST set our proposal
# to that value.
if accepted_value is not None:
self.proposed_value[self.index] = accepted_value
if noMoreAccepted:
self.num_noMoreAccepted[self.index] += 1
if len(self.promises_rcvd) > self.quorum_size/2:
if self.num_noMoreAccepted[self.index] > self.quorum_size/2:
self.prepared = True
if self.proposed_value[self.index] is not None:
self.accepted_rcvd = set()
self.amulti.accept(self.proxy, self.index, self.min_proposal, self.proposed_value[self.index], self.first_unchosen_index)
self.promises_rcvd = set()
def accepted(self, proxy, n, first_unchosen_index):
self.accepted_rcvd.add( proxy.get_id())
if n > self.min_proposal:
self.max_round = n
self.prepared = False
# self.prepare()
if first_unchosen_index <= self.last_log_index and self.accepted_proposal[first_unchosen_index] == 0:
result = proxy.success(first_unchosen_index, self.accepted_value[first_unchosen_index])
self.index = result
while True:
if (result < self.first_unchosen_index):
result = proxy.success(result, self.accepted_value[result])
self.index = result
else:
break
if len(self.accepted_rcvd) > self.quorum_size/2:
self.accepted_proposal[self.index] = 0
self.accepted_value[self.index] = self.proposed_value[self.index]
self.current_client.internal_get(self.accepted_value[self.index])
class Proposer (object):
_sync = {}
_async = ['set_multi', 'prepare', 'promise', 'set_proposal']
_ref = ['set_multi']
_parallel = []
def __init__(self, quorum_size):
self.quorum_size = quorum_size
self.proposed_value = None
self.last_accepted_id = None
self.next_proposal_number = 1
#async, ref
def set_multi(self, list_acceptors):
self.list_acceptors = list_acceptors
self.amulti = AMulti(self.list_acceptors)
self.smulti = SMulti(self.list_acceptors, self._atom)
def set_proposal(self, value):
'''
Sets the proposal value for this node if this node is not already aware of
another proposal having already been accepted.
'''
if self.proposed_value is None:
self.proposed_value = value
def prepare(self):
'''
Sends a prepare request to all Acceptors as the first step in attempting to
acquire leadership of the Paxos instance.
'''
self.promises_rcvd = set()
self.proposal_id = ProposalID(self.next_proposal_number, self.id)
print 'holaa', self.proposal_id
self.next_proposal_number += 1
#multi to all acceptors!!
result = self.smulti.onPrepare(self.proxy, self.proposal_id)
self.promise(result)
def promise(self, infoAcceptors):
'''
Called when a Promise message is received from an Acceptor
'''
for a in infoAcceptors:
# Ignore the message if it's for an old proposal or we have already received
# a response from this Acceptor
if a[1] != self.proposal_id or a[0] in self.promises_rcvd:
None
else:
self.promises_rcvd.add( a[0] )
if a[2] > self.last_accepted_id:
self.last_accepted_id = a[2]
# If the Acceptor has already accepted a value, we MUST set our proposal
# to that value.
if a[2] is not None:
self.proposed_value = a[3]
if len(self.promises_rcvd) > self.quorum_size/2:
if self.proposed_value is not None:
self.amulti.accept(self.id, self.proposal_id, self.proposed_value)
break
def set_multi(self, list_acceptors):
self.list_acceptors = list_acceptors
self.amulti = AMulti(self.list_acceptors)
self.smulti = SMulti(self.list_acceptors, self._atom)
def add_actors(self, list_actors):
self.supervisor = Supervisor(5, 3, self._atom, list_actors)
self.amulti = AMulti(list_actors)
self.smulti = SMulti(self._atom, list_actors)
return True
def add_actors(self, list_actors):
self.amulti = AMulti(list_actors)
self.smulti = SMulti(list_actors, self._atom)
def set_cohorts(self,cohortlist):
self.amulti = AMulti(cohortlist)
print 'self.amulti', self.amulti
self.smulti = SMulti(self._atom, cohortlist)
print 'self.smulti', self.smulti
return True
def add_actors(self, list_actors):
print list_actors
self.amulti = AMulti(list_actors)
self.smulti = SMulti(self._atom, list_actors)
self.list_actors = list_actors
