def main(log_dir, node, cluster):
loop = asyncio.new_event_loop()
raftos.configure({
'log_path': log_dir,
'serializer': raftos.serializers.JSONSerializer,
'loop': loop
})
loop.run_until_complete(run(loop, node, cluster))
def test_configure(self):
raftos.configure({
'log_path': '/test_path/',
'serializer': 'TestSerializer',
'heartbeat_interval': 0.2,
'election_interval': (0.8, 2)
})
self.assertEqual(raftos.config.log_path, '/test_path/')
self.assertEqual(raftos.config.serializer, 'TestSerializer')
self.assertEqual(raftos.config.heartbeat_interval, 0.2)
self.assertEqual(raftos.config.election_interval, (0.8, 2))
def __init__(self):
raftos.configure({
'log_path': '/tmp',
'serializer': raftos.serializers.JSONSerializer
})
self.conf = common.CLUSTER_CONF
self.clusters = [
'{}:{}'.format(cluster, self.conf.get('raft_port'))
for cluster in self.conf.get('raft_cluster_machines')
if cluster != common.vip.ip
]
self.node = '{}:{}'.format(common.vip.ip, self.conf.get('raft_port'))
self.raft_thread = None
self.monitor_thread = None
def test_configure(self):
raftos.configure({
'log_path': '/test_path/',
'serializer': 'TestSerializer',
'secret_key': b'raftos test secret key',
'salt': b'raftos test salt'
})
self.assertEqual(raftos.config.log_path, '/test_path/')
self.assertEqual(raftos.config.serializer, 'TestSerializer')
self.assertEqual(
raftos.config.secret_key,
b'raftos test secret key',
)
self.assertEqual(raftos.config.salt, b'raftos test salt')
def __init__(self, num_nodes, node_id, start_time):
# Add member
self.num_nodes = num_nodes
self.node_id = node_id
self.start_time = start_time
# RaftOS can perform callbacks for the same request
# So we add a time -> request dict for quick replicate lookup
self.registry = AtomicDict()
# Submitted requests via Rest API
# self.api_queue -> [{'time': str, 'request': str}]
self.api_queue = AtomicQueue()
# Requests to send to Clipper
# self.clipper_queue -> [str]
self.clipper_queue = AtomicQueue()
# Retrieve asyncio loop
self.loop = asyncio.get_event_loop()
# Configure raftos
self.raft_node = '127.0.0.1:{}'.format(8000 + self.node_id)
self.raft_cluster = [
'127.0.0.1:{}'.format(8000 + i) for i in range(num_nodes)
if i != self.node_id
]
self.timestamp = start_time.strftime('%Y-%m-%d-%H-%M-%S')
self.log_dir = './logs/{}'.format(self.timestamp)
os.makedirs('./logs', exist_ok=True)
os.makedirs(self.log_dir, exist_ok=True)
raftos.configure({
'log_path':
self.log_dir,
'serializer':
raftos.serializers.JSONSerializer,
'on_receive_append_entries_callback':
self.on_receive_append_entries_callback
})
# Configure REST API
self.rest_api = BoatAPI(self, '127.0.0.1', 8080 + self.node_id)
def main():
args = get_args()
# setup_logging(args) # FIXME this should work!!! but it doesn't yet
setup_intercepts()
raftos.configure({
"on_leader": partial(log_state, "leader"),
"on_follower": partial(log_state, "follower"),
})
loop = asyncio.get_event_loop()
try:
loop.create_task(register_raftos(args.cluster_id, args.cluster))
loop.create_task(watch_nodes())
loop.run_forever()
except KeyboardInterrupt:
log.info("Service process interrupted")
finally:
loop.close()
log.info("Successful shutdown of Raftos-based service.")
def _get_signature(self, params=None):
if params is None:
params = {}
msg = ''.join(map(str, sorted(params.values()))).encode()
return hmac.new(self.key.encode(), msg=msg).hexdigest()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--conf')
parser.add_argument('--node')
parser.add_argument('--cluster')
args = parser.parse_args()
cluster = ['127.0.0.1:{}'.format(port) for port in args.cluster.split()]
node = '127.0.0.1:{}'.format(args.node)
beatle = Beatle(config_path=args.conf, beatle_id=node)
logger.info('Starting beatle node: {}'.format(node))
loop = asyncio.get_event_loop()
loop.create_task(raftos.register(node, cluster=cluster))
raftos.configure({
'log_path': '/var/log/beatle/',
'serializer': raftos.serializers.JSONSerializer,
'on_leader': beatle.on_leader
})
loop.run_until_complete(beatle.run())
current_id = random.randint(1, 1000)
data_map = {
str(current_id): {
'created_at': datetime.now().strftime('%d/%m/%y %H:%M')
}
}
await data_id.set(current_id)
await data.update(data_map)
await data_list.append(data_map)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--node')
parser.add_argument('--cluster')
args = parser.parse_args()
cluster = ['127.0.0.1:{}'.format(port) for port in args.cluster.split()]
node = '127.0.0.1:{}'.format(args.node)
raftos.configure({
'log_path': './',
'serializer': raftos.serializers.JSONSerializer
})
loop = asyncio.get_event_loop()
loop.create_task(raftos.register(node, cluster=cluster))
loop.run_until_complete(run(node))
async def alarm(self, future):
chat_id = await future
if chat_id:
await self.sendMessage(chat_id, 'Here you go!')
await self.alarms.delete(chat_id)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--node')
parser.add_argument('--cluster')
args = parser.parse_args()
cluster = ['127.0.0.1:{}'.format(port) for port in args.cluster.split()]
node_id = '127.0.0.1:{}'.format(args.node)
bot = RelyBot(open('token').readline().strip())
raftos.configure({
'log_path': './',
'serializer': raftos.serializers.JSONSerializer,
'on_leader': bot.start,
'on_follower': bot.stop
})
loop = asyncio.get_event_loop()
loop.create_task(raftos.register(node_id, cluster=cluster))
loop.run_until_complete(bot.idle())
class Class:
data = raftos.Replicated(name='data')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--node')
parser.add_argument('--cluster')
args = parser.parse_args()
cluster = ['127.0.0.1:{}'.format(port) for port in args.cluster.split()]
node = '127.0.0.1:{}'.format(args.node)
raftos.configure({
'log_path': './'
})
raftos.register(node, cluster=cluster)
obj = Class()
while True:
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.sleep(5))
try:
obj.data = {
'id': random.randint(1, 1000),
'data': {
'amount': random.randint(1, 1000) * 1000,
'created_at': datetime.now().strftime('%d/%m/%y %H:%M')
}
