def importDataSet(self) -> Tuple[int, int, int, int, int, int, list]:
if os.path.isfile(self.filename):
with open(self.filename, 'r') as file:
content = file.readlines()
R, C, F, N, B, T = list(map(int, content[0].split(" ")))
rides = []
lines = iter(content)
next(lines)
counter: int = 0
for line in lines:
a, b, x, y, s, f = list(map(int, line.split(" ")))
start = Intersection(a, b)
end = Intersection(x, y)
ride = Ride(counter, start, end, s, f)
rides.append(ride)
counter += 1
file.close()
return R, C, F, N, B, T, rides
else:
print("Error: File not found")
raise FileNotFoundError
def start(quorum_id_a=None, quorum_id_b=None):
if app.config[PBFT_INSTANCES] is not None:
app.logger.warning("peer has already started, restarting")
del app.config[PBFT_INSTANCES]
instance_a = SawtoothContainer()
instance_b = SawtoothContainer()
app.config[PBFT_INSTANCES] = Intersection(instance_a, instance_b,
quorum_id_a, quorum_id_b)
app.config[QUORUMS][quorum_id_a] = []
app.config[QUORUMS][quorum_id_b] = []
return ROUTE_EXECUTED_CORRECTLY
def make_single_intersection(instances: list, committee_size: int):
peers = []
for row in range(committee_size + 1):
for column in range(row, committee_size):
peers.append(
Intersection(instances[row][column],
instances[column + 1][row], row, column + 1), )
util_logger.info(
"In committee {a} committee Member {a_ip} matches {b_ip} in committee {b}"
.format(a=row,
a_ip=instances[row][column].ip(),
b_ip=instances[column + 1][row].ip(),
b=column + 1))
return peers
def test_peer_setup(self):
a = SawtoothContainer()
b = SawtoothContainer()
id_a = '1'
id_b = '2'
inter = Intersection(a, b, id_a, id_b)
self.assertEqual(inter.committee_id_a, id_a)
self.assertEqual(inter.committee_id_b, id_b)
self.assertEqual(inter.ip(id_a), a.ip())
self.assertEqual(inter.ip(id_b), b.ip())
self.assertEqual(inter.attached_network(), DEFAULT_DOCKER_NETWORK)
self.assertTrue(inter.in_committee(id_a))
self.assertTrue(inter.in_committee(id_b))
self.assertFalse(inter.in_committee('c'))
self.assertFalse(inter.in_committee(0))
del a, b, inter
a = SawtoothContainer('host')
b = SawtoothContainer('host')
id_a = '1'
id_b = '2'
inter = Intersection(a, b, id_a, id_b)
self.assertEqual(inter.attached_network(), 'host')
def test_start_with_peer(self):
a = SawtoothContainer()
b = SawtoothContainer()
id_a = 'a'
id_b = 'b'
p = Intersection(a, b, id_a, id_b)
app = api.create_app(p)
app.config['TESTING'] = True
app.config['DEBUG'] = False
client = app.test_client()
docker = docker_api.from_env()
# get info on container a
container_ip = docker.containers.list()[1].exec_run(
"hostname -i").output.decode('utf-8').strip()
container_val_key = docker.containers.list()[1].exec_run("cat {val_pub}".format(val_pub=VKEY["pub"])) \
.output.decode('utf-8').strip()
container_user_key = docker.containers.list()[1].exec_run("cat {user_pub}".format(user_pub=UKEY["pub"])) \
.output.decode('utf-8').strip()
self.assertEqual(get_plain_text(client.get('/ip/a')), container_ip)
self.assertEqual(get_plain_text(client.get('/val+key/a')),
container_val_key)
self.assertEqual(get_plain_text(client.get('/user+key/a')),
container_user_key)
self.assertNotEqual(get_plain_text(client.get('/val+key/a')),
get_plain_text(client.get('/user+key/a')))
# get info on container b
container_ip = docker.containers.list()[0].exec_run(
"hostname -i").output.decode('utf-8').strip()
container_val_key = docker.containers.list()[0].exec_run("cat {val_pub}".format(val_pub=VKEY["pub"])) \
.output.decode('utf-8').strip()
container_user_key = docker.containers.list()[0].exec_run("cat {user_pub}".format(user_pub=UKEY["pub"])) \
.output.decode('utf-8').strip()
self.assertEqual(get_plain_text(client.get('/ip/b')), container_ip)
self.assertEqual(get_plain_text(client.get('/val+key/b')),
container_val_key)
self.assertEqual(get_plain_text(client.get('/user+key/b')),
container_user_key)
self.assertNotEqual(get_plain_text(client.get('/val+key/b')),
get_plain_text(client.get('/user+key/b')))
def test_peer_join(self):
intersections = make_peer_committees(7)
id_a = intersections[0].committee_id_a
id_b = intersections[0].committee_id_b
intersections[0].submit(Transaction(id_a, 'update_a_1', 999))
number_of_tx = 2
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx, 'update_a_1', ))
intersections[0].submit(Transaction(id_b, 'update_b_1', 999))
self.assertTrue(check_for_confirmation([i.instance_b for i in intersections], number_of_tx, 'update_b_1', ))
intersections.append(Intersection(SawtoothContainer(), SawtoothContainer(), id_a, id_b))
committee_ips_a = [inter.instance_a.ip() for inter in intersections]
committee_ips_b = [inter.instance_b.ip() for inter in intersections]
intersections[-1].peer_join(id_a, committee_ips_a)
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx - 1)) # catch up
intersections[0].update_committee(id_a, [inter.instance_a.val_key() for inter in intersections])
number_of_tx += 1
intersections[0].submit(Transaction(id_a, 'update_a_2', 888))
number_of_tx += 1
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx, 'update_a_2'))
intersections[-1].peer_join(id_b, committee_ips_b)
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx - 1)) # catch up
intersections[0].update_committee(id_b, [inter.instance_b.val_key() for inter in intersections])
intersections[0].submit(Transaction(id_b, 'update_b_2', 888))
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx, 'update_b_2'))
# makes sure all intersections are configured to work with each other (this is not a test of connectivity
# just config) and make sure they all have the three tx
for inter in intersections:
intersections_config = inter.sawtooth_api(id_a, 'http://localhost:8008/peers')['data']
for ip in committee_ips_a:
if ip != inter.ip(id_a): # the peer it's self is not reported in the list
self.assertIn("tcp://{}:8800".format(ip), intersections_config)
intersections_config = inter.sawtooth_api(id_b, 'http://localhost:8008/peers')['data']
for ip in committee_ips_b:
if ip != inter.ip(id_b):
self.assertIn("tcp://{}:8800".format(ip), intersections_config)
def test_setting_instances(self):
a = SawtoothContainer()
b = SawtoothContainer()
inter = Intersection(a, b, 'a', 'b')
peer = SmartShardPeer(inter)
peer.start()
client = peer.app.api.test_client()
docker = docker_api.from_env()
# get info on container a
container_ip = docker.containers.list()[1].exec_run(
"hostname -i").output.decode('utf-8').strip()
container_val_key = docker.containers.list()[1].exec_run("cat {val_pub}".format(val_pub=VKEY["pub"])) \
.output.decode('utf-8').strip()
container_user_key = docker.containers.list()[1].exec_run("cat {user_pub}".format(user_pub=UKEY["pub"])) \
.output.decode('utf-8').strip()
self.assertEqual(get_plain_text(client.get('/ip/a')), container_ip)
self.assertEqual(get_plain_text(client.get('/val+key/a')),
container_val_key)
self.assertEqual(get_plain_text(client.get('/user+key/a')),
container_user_key)
self.assertNotEqual(get_plain_text(client.get('/val+key/a')),
get_plain_text(client.get('/user+key/a')))
# get info on container b
container_ip = docker.containers.list()[0].exec_run(
"hostname -i").output.decode('utf-8').strip()
container_val_key = docker.containers.list()[0].exec_run("cat {val_pub}".format(val_pub=VKEY["pub"])) \
.output.decode('utf-8').strip()
container_user_key = docker.containers.list()[0].exec_run("cat {user_pub}".format(user_pub=UKEY["pub"])) \
.output.decode('utf-8').strip()
self.assertEqual(get_plain_text(client.get('/ip/b')), container_ip)
self.assertEqual(get_plain_text(client.get('/val+key/b')),
container_val_key)
self.assertEqual(get_plain_text(client.get('/user+key/b')),
container_user_key)
self.assertNotEqual(get_plain_text(client.get('/val+key/b')),
get_plain_text(client.get('/user+key/b')))
def test_committee_setup_single(self):
id_a = '1'
id_b = '2'
containers_a = [SawtoothContainer() for _ in range(4)]
user_keys_a = [i.user_key() for i in containers_a]
val_keys_a = [i.val_key() for i in containers_a]
committee_ips_a = [i.ip() for i in containers_a]
containers_b = [SawtoothContainer() for _ in range(4)]
user_keys_b = [i.user_key() for i in containers_b]
val_keys_b = [i.val_key() for i in containers_b]
committee_ips_b = [i.ip() for i in containers_b]
intersections = [Intersection(containers_a[i], containers_b[i], id_a, id_b) for i in range(4)]
intersections[0].make_genesis(id_a, val_keys_a, user_keys_a)
intersections[0].make_genesis(id_b, val_keys_b, user_keys_b)
for inter in intersections:
inter.start_sawtooth(committee_ips_a, committee_ips_b)
# make sure genesis is in every peer and that they can communicate with other committee members
self.assertEqual(len(intersections), 4)
for inter in intersections:
self.assertEqual(len(inter.blocks(id_a)), 1)
for inter in intersections:
self.assertEqual(len(inter.blocks(id_b)), 1)
# make sure util func works
del containers_a
del containers_b
intersections = make_peer_committees(4)
self.assertEqual(len(intersections), 4)
for inter in intersections:
self.assertEqual(len(inter.blocks(id_a)), 1)
for inter in intersections:
self.assertEqual(len(inter.blocks(id_b)), 1)
def test_addIfValid2(self):
# Not a valid add -- Tests for adding a word out of bounds
interCell = testBoard.getCellAt(2, 0)
inter = Intersection("HELLO", "HELL", 2, 2)
self.assertTrue(testBoard.addIfValid(interCell, inter, "HELL"))
def test_addIfValid1(self):
# This is a valid add
interCell = testBoard.getCellAt(0, 3)
inter = Intersection("PARTY", "HELP", 0, 3)
testBoard.addIfValid(interCell, inter, "PARTY")
testBoard.terminalRepresentationOfCrossword()
def test_addIfValid0(self):
interCell = testBoard.getCellAt(0, 0)
inter = Intersection("HELLO", "HELP", 0, 0)
self.assertTrue(testBoard.addIfValid(interCell, inter, False))
testBoard.terminalRepresentationOfCrossword()
def __init__(self):
self.location: "Intersection" = Intersection(0, 0)
self.ride: "Ride" = None
self.previousRides: List[Ride] = []
self.timeWhenAvailable: int = 0
def test_committee_independent_join(self):
intersections = make_peer_committees(7)
number_of_tx_a = 1
id_a = intersections[0].committee_id_a
new_peer = Intersection(SawtoothContainer(), None, id_a, None)
committee_ips_a = [inter.ip(id_a) for inter in intersections]
committee_ips_a.append(new_peer.ip(id_a))
committee_val_a = [inter.val_key(id_a) for inter in intersections]
committee_val_a.append(new_peer.val_key(id_a))
intersections[0].submit(Transaction(id_a, 'update_a_1', 999))
number_of_tx_a += 1
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx_a, 'update_a_1'))
new_peer.peer_join(id_a, committee_ips_a)
intersections[0].update_committee(id_a, committee_val_a)
number_of_tx_a += 1
intersections[0].submit(Transaction(id_a, 'update_a_2', 888))
number_of_tx_a += 1
self.assertTrue(check_for_confirmation([i.instance_a for i in intersections], number_of_tx_a, 'update_a_2'))
# confirm membership
committee_a = intersections.copy()
committee_a.append(new_peer)
self.assertEqual(None, new_peer.committee_id_b)
for inter in committee_a:
intersections_config = inter.sawtooth_api(id_a, 'http://localhost:8008/peers')['data']
for ip in committee_ips_a:
if ip != inter.ip(id_a): # the peer it's self is not reported in the list
self.assertIn("tcp://{}:8800".format(ip), intersections_config)
for inter in committee_a:
self.assertEqual(number_of_tx_a, len(inter.blocks(id_a)))
# now committee B
id_b = intersections[0].committee_id_b
number_of_tx_b = 1
new_peer = Intersection(None, SawtoothContainer(), None, id_b)
committee_ips_b = [inter.ip(id_b) for inter in intersections]
committee_ips_b.append(new_peer.ip(id_b))
committee_val_b = [inter.val_key(id_b) for inter in intersections]
committee_val_b.append(new_peer.val_key(id_b))
intersections[0].submit(Transaction(id_b, 'update_b_1', 999))
number_of_tx_b += 1
self.assertTrue(check_for_confirmation([i.instance_b for i in intersections], number_of_tx_b, 'update_b_1'))
new_peer.peer_join(id_b, committee_ips_b)
intersections[0].update_committee(id_b, committee_val_b)
number_of_tx_b += 1
self.assertTrue(check_for_confirmation([i.instance_b for i in intersections], number_of_tx_b))
intersections[0].submit(Transaction(id_b, 'update_b_2', 888))
number_of_tx_b += 1
self.assertTrue(check_for_confirmation([i.instance_b for i in intersections], number_of_tx_b, 'update_b_2'))
# confirm membership
committee_b = intersections.copy()
committee_b.append(new_peer)
for inter in committee_b:
intersections_config = inter.sawtooth_api(id_b, 'http://localhost:8008/peers')['data']
for ip in committee_ips_b:
if ip != inter.ip(id_b): # the peer it's self is not reported in the list
self.assertIn("tcp://{}:8800".format(ip), intersections_config)
for inter in committee_b:
self.assertEqual(number_of_tx_b, len(inter.blocks(id_b)))
def make_peer_committees(size: int, id_a=1, id_b=2):
containers_a = make_sawtooth_committee(size)
containers_b = make_sawtooth_committee(size)
intersections = [Intersection(containers_a[i], containers_b[i], id_a, id_b) for i in range(size)]
return intersections
