def test_erdos_renyi_topology(self):
topology = fnss.erdos_renyi_topology(1000, 0.2)
topology_fast = fnss.erdos_renyi_topology(1000, 0.2, fast=True)
for t in (topology, topology_fast):
self.assertEqual(1000, t.number_of_nodes())
self.assertRaises(ValueError, fnss.erdos_renyi_topology, -1, 0.2)
self.assertRaises(ValueError, fnss.erdos_renyi_topology, 40, 1.2)
self.assertRaises(ValueError, fnss.erdos_renyi_topology, 50, -0.2)
def test_erdos_renyi_topology(self):
topology = fnss.erdos_renyi_topology(1000, 0.2)
topology_fast = fnss.erdos_renyi_topology(1000, 0.2, fast=True)
for t in (topology, topology_fast):
self.assertEqual(1000, t.number_of_nodes())
self.assertRaises(ValueError, fnss.erdos_renyi_topology, -1, 0.2)
self.assertRaises(ValueError, fnss.erdos_renyi_topology, 40, 1.2)
self.assertRaises(ValueError, fnss.erdos_renyi_topology, 50, -0.2)
def erdoes_renyi(self, **args):
"""
Creates a random Erdoes-Renyi Graph.
Args:
order (int): Number of nodes.
connectivity (float): Probability that two nodes are connected.
Must be in (0; 1].
args (dict): Attributes for property generation:
min_bw (int): Minimal value for bandwidth on edge.
max_bw (int): Maximal value for bandwidth on edge.
bandwidth (string): {uniform, power} - How bandwidth should be
generated. If uniform is chosen distribution follows uniform
distribution, if power is chosen distribution follows a
power law.
min_cpu (int): Minimal value for CPU capacity.
max_cpu (int): Maximal value for CPU capacity.
min_distance (int): Minimal length of an edge.
max_distance (int): Maximal length of an edge.
delay (float, optional): Delay per kilometer of cable length.
substrate (optional, bool): Whether it is a substrate network.
Returns: FNSS Graph
"""
unconnected = True
num_nodes = args.pop('order')
connectivity = args.pop('connectivity')
vnr = None
while unconnected:
vnr = fnss.erdos_renyi_topology(n=num_nodes, p=connectivity)
unconnected = not nx.is_connected(vnr)
self.remove_unnecessary_attributes(args)
self.generate_attributes(vnr, **args)
vnr.graph['model'] = literals.NETWORK_MODEL_ERDOES_RENYI
return vnr
def test_fast_erdos_renyi_topology_zero_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=0)
b = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=0)
self.assertEqual(set(a.edges()), set(b.edges()))
def test_fast_erdos_renyi_topology_constant_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=1)
b = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=2)
c = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=1)
self.assertEqual(set(a.edges()), set(c.edges()))
self.assertNotEqual(set(a.edges()), set(b.edges()))
def test_erdos_renyi_topology_no_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2)
b = fnss.erdos_renyi_topology(100, 0.2)
self.assertNotEqual(set(a.edges()), set(b.edges()))
def test_fast_erdos_renyi_topology_zero_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=0)
b = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=0)
self.assertEqual(set(a.edges()), set(b.edges()))
def test_fast_erdos_renyi_topology_constant_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=1)
b = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=2)
c = fnss.erdos_renyi_topology(100, 0.2, fast=True, seed=1)
self.assertEqual(set(a.edges()), set(c.edges()))
self.assertNotEqual(set(a.edges()), set(b.edges()))
def test_erdos_renyi_topology_no_seed(self):
a = fnss.erdos_renyi_topology(100, 0.2)
b = fnss.erdos_renyi_topology(100, 0.2)
self.assertNotEqual(set(a.edges()), set(b.edges()))
def setUp(self):
self.connection_params = {
'db_name': 'TestDb',
'host': 'localhost',
'port': 3366,
'user': '******',
'password': '******'
}
vne_interface.DbManager.set_connection_parameter(
**self.connection_params)
vne_interface.DbManager.connect()
with vne_interface.dm.db.transaction() as txn:
try:
vne_interface.dm.db.create_tables([
vne_interface.dm.EventGenerationSetting,
vne_interface.dm.VnrGenerationSetting,
vne_interface.dm.AlgorithmSetting,
vne_interface.dm.Network, vne_interface.dm.Node,
vne_interface.dm.Edge, vne_interface.dm.NetworkAttribute,
vne_interface.dm.SubstrateGenerationSetting,
vne_interface.dm.EventHeap, vne_interface.dm.Experiment,
vne_interface.dm.LearningModel, vne_interface.dm.Setup
])
self.algo_setting = vne_interface.dm.AlgorithmSetting.create(
parameter=
'{"alpha": 0.5, "beta": 0.5, "name": "melo_sdp", "timeout": 65.0}'
)
self.event_setting = vne_interface.dm.EventGenerationSetting.create(
parameter=
'{"model": "erdoes_renyi", "lmbd": 10, "num_requests": 5, "avg_life_time": 1000}'
)
self.vnr_setting = vne_interface.dm.VnrGenerationSetting.create(
parameter=
'{"min_bw": 0, "max_cpu": 50, "maxy": 100, "miny": 0, '
'"min_cpu": 0, "max_bw": 50, "minx": 0, "connectivity": 0.5, '
'"bandwidth": "uniform", "max_num_nodes": 22, '
'"min_num_nodes": 8, "max_distance": 501, '
'"min_distance": 500, "maxx": 100}')
self.substrate_setting = vne_interface.dm.SubstrateGenerationSetting.create(
parameter='{"min_bw": 50, "max_cpu": 100, "maxy": 100, '
'"substrate": true, "miny": 0, "min_cpu": 50, '
'"bandwidth": "uniform", "num_nodes": 43, "minx": 0, '
'"connectivity": 0.5, "max_bw": 100, "max_distance": 50, '
'"model": "erdoes_renyi", "min_distance": 1, "maxx": 100}')
substrate = fnss.erdos_renyi_topology(43, 0.5)
fnss.set_capacities_random_uniform(substrate, range(50, 100))
for attributes in substrate.node.itervalues():
attributes['cpu'] = np.random.uniform(50, 100)
networkif = vne_interface.Network.from_fnss_topology(substrate)
self.substrate = networkif.network_model
self.learning_model = vne_interface.dm.LearningModel.create(
type='testmode',
serialized_model='/path/to/model.pkl',
aux_params='empty',
comment=
'This model is created from setup method of unittest')
self.experiment = vne_interface.dm.Experiment.create(
description=
'Created for test purposes from setup method of unittest')
self.event_heaps = []
for i in range(5):
self.event_heaps.append(
vne_interface.dm.EventHeap.create(
event_generation_setting_id=self.event_setting.
event_generation_setting_id,
vnr_generation_setting_id=self.vnr_setting.
vnr_generation_setting_id))
self.setups = []
for heap in self.event_heaps:
self.setups.append(
vne_interface.dm.Setup.create(
event_generation_setting=self.event_setting,
vnr_generation_setting=self.vnr_setting,
substrate_generation_setting=self.
substrate_setting,
algorithm_setting=self.algo_setting,
experiment=self.experiment,
event_heap=heap,
description=
'Test Setup created from unittest setup method',
substrate=self.substrate,
learning_model_id=self.learning_model.
learning_model_id))
txn.commit()
except Exception as e:
logging.exception(e)
txn.rollback()
