def load_message(data):
try:
o = json.loads(data)
except json.decoder.JSONDecodeError as e:
raise Message.InvalidMessageError(e)
if 'type_name' not in o:
raise Message.InvalidMessageError('field, `type_name` is missing: %s',
o)
if o['type_name'] == 'message':
return Message.from_json(data)
if o['type_name'] == 'ballot-message':
return BallotMessage.from_json(data)
def send_accepted(self, proposal_uid, accepted_value):
"""
Broadcasts an Accepted message to all Learners
"""
for i, addr in enumerate(SERVER_ADDRESSES):
msg = Message(
Message.MSG_DECIDE, self.owner.uid,
(self.owner.server.address, self.owner.server.port), (addr, LEARNER_PORT + i*10),
data=(proposal_uid, accepted_value))
self.owner.server.send_message(msg)
def send_proposal(self, replica_id, proposal_value):
"""
Broadcasts an (uid, value) message to all Acceptors
"""
for i, addr in enumerate(SERVER_ADDRESSES):
if i != replica_id:
msg = Message(
Message.MSG_ACCEPT, self.owner.uid,
(self.owner.server.address, self.owner.server.port), (addr, ACCEPTOR_PORT + i*10),
data=(replica_id, proposal_value))
self.owner.server.send_message(msg)
def send_prepare(self, proposal_id):
"""
Broadcasts a Prepare message to all Acceptors
"""
for i, addr in enumerate(SERVER_ADDRESSES):
msg = Message(Message.MSG_PREPARE,
self.owner.uid,
(self.owner.server.address, self.owner.server.port),
(addr, ACCEPTOR_PORT + i * 10),
data=proposal_id)
self.owner.server.send_message(msg)
def send_promise(self, proposer_uid, proposal_id, previous_id,
accepted_value):
"""
Sends a Promise message to the specified Proposer
"""
msg = Message(Message.MSG_PROMISE,
self.owner.uid,
(self.owner.server.address, self.owner.server.port),
(SERVER_ADDRESSES[proposer_uid],
PROPOSER_PORT + proposer_uid * 10),
data=(proposal_id, previous_id, accepted_value))
self.owner.server.send_message(msg)
def join(self, name, actor_type):
"""Sends the join request to the server.
:param name: Player name to join with.
:type name: str
:param actor_type: Player type
:type actor_type: :enum:`game.player.PlayerType`
"""
LOG.info('Trying to join server')
msg = Message(MT.join, {MF.name: name, MF.entity_type: actor_type})
self.proxy.enqueue(msg)
def ping(self):
"""Pings the server to start te timing offset calculation.
"""
LOG.debug('Sending ping')
# Create and enqueue the ping message
sync_id = next(self.sync_counter)
msg = Message(MT.ping, {MF.id: sync_id, MF.timestamp: tstamp()})
def callback():
self._syncing[sync_id] = tstamp()
self.proxy.enqueue(msg, callback)
def start_move_action(context, position):
"""Start a move action to the defined position.
:param context: The game context.
:type context: :class:`context.Context`
:param position: The position in world ccoordinates
:type position: :class:`tuple`
"""
msg = Message(MessageType.move, {
MessageField.x_pos: position[0],
MessageField.y_pos: position[1],
})
context.msg_queue.append(msg)
def on_resolution(self, proposal_uid, value, log=None):
"""
Called when a resolution is reached
"""
print('###')
print('Value {v} is accepted by {o}, proposed by {pid}.'.format(v=value, o=self.owner.server.port, pid=proposal_uid))
print('###')
time.sleep(2)
for i, addr in enumerate(SERVER_ADDRESSES):
msg = Message(
Message.MSG_STOP, self.owner.uid,
(self.owner.server.address, self.owner.server.port), (addr, NODE_PORT + i*10), data=(proposal_uid, value, log))
self.owner.server.send_message(msg)
async def check_message_in_storage(node):
global MESSAGE
if check_message_in_storage.is_running:
return
check_message_in_storage.is_running = True
found = list()
log.main.info('%s: checking input message was stored: %s', node.name,
MESSAGE)
while len(found) < len(servers):
for node_name, server in servers.items():
if node_name in found:
continue
storage = server.consensus.storage
is_exists = storage.is_exists(MESSAGE)
if is_exists:
log.main.critical(
'> %s: is_exists=%s state=%s ballot=%s',
node_name,
is_exists,
server.consensus.ballot.state,
# json.dumps(storage.ballot_history.get(MESSAGE.message_id), indent=2),
'', # json.dumps(storage.ballot_history.get(MESSAGE.message_id)),
)
found.append(node_name)
await asyncio.sleep(0.01)
await asyncio.sleep(3)
check_message_in_storage.is_running = False
MESSAGE = Message.new(uuid1().hex)
servers['n0'].transport.send(nodes['n0'].endpoint,
MESSAGE.serialize(client0_node))
log.main.info('inject message %s -> n0: %s', client0_node.name, MESSAGE)
return
def start_build_action(context, position):
"""Start a build action to the defined position.
NOTE: the game context has all the information required.
:param context: The game context.
:type context: :class:`context.Context`
:param position: The position in world coordinates
:type position: :class:`tuple`
"""
building_type = context.building_type
msg = Message(
MessageType.build, {
MessageField.building_type: building_type,
MessageField.x_pos: position[0],
MessageField.y_pos: position[1],
})
context.msg_queue.append(msg)
send_event(GameModeToggle(context.GameMode.building))
def from_json(cls, data):
try:
o = json.loads(data)
except json.decoder.JSONDecodeError as e:
raise cls.InvalidBallotMessageError(e)
if 'type_name' not in o or o['type_name'] != 'ballot-message':
raise cls.InvalidBallotMessageError(
'`type_name` is not "ballot-message"')
message = None
try:
message = Message.from_dict(o)
except Message.InvalidMessageError as e:
raise cls.InvalidBallotMessageError(e)
return cls(
Node(o['node'], None, None),
State.from_name(o['state']),
message,
BallotVoteResult.from_name(o['result']),
)
transports[name] = LocalTransport(name, config.endpoint, loop)
log.main.debug('transports created: %s', transports)
consensuses[name] = TestConsensus(nodes[name], quorums[name],
transports[name])
log.main.debug('consensuses created: %s', consensuses)
servers[name] = Server(nodes[name],
consensuses[name],
name,
transport=transports[name])
log.main.debug('servers created: %s', servers)
for server in servers.values():
server.start()
# send message to `server0`
MESSAGE = Message.new(uuid1().hex)
servers['n0'].transport.send(nodes['n0'].endpoint,
MESSAGE.serialize(client0_node))
log.main.info('inject message %s -> n0: %s', client0_node.name, MESSAGE)
try:
loop.run_forever()
except (KeyboardInterrupt, SystemExit):
log.main.debug('goodbye~')
sys.exit(1)
finally:
loop.close()