def download_resv_rspec(request, slice_id):
slice = get_object_or_404(Slice, pk=slice_id)
rspec = create_resv_rspec(request.user, slice)
response = HttpResponse(rspec, mimetype='application/force-download')
response['Content-Disposition'] = 'attachment; filename=resv_rspec.xml'
return response
def test_reserve_sliver(self):
self.test_add_aggregate()
proj_name = "test project"
proj_desc = "test project description"
slice_name = "test slice"
slice_desc = "test slice description"
username = "******"
firstname = "gapi"
lastname = "user"
password = "******"
affiliation = "Stanford"
email = "*****@*****.**"
controller_url = "tcp:bla.com:6633"
fs1 = dict(
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(4455, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
)
fs2 = dict(
dl_src=("11:22:33:44:55:66", "11:22:33:44:55:77"),
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(None, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
nw_proto=(4, 4),
tp_src=(123, 123),
)
agg = GCFOpenFlowAggregate.objects.all()[0]
# setup threadlocals
tl = threadlocals.get_thread_locals()
tl["user"] = self.su
project = Project.objects.create(
name=proj_name,
description=proj_desc,
)
tl["project"] = project
url = reverse("project_add_agg", args=[project.id])
response = self.client.post(
path=url,
data={"id": agg.id},
)
self.assertTrue(project.aggregates.count() == 1)
self.assertRedirects(
response,
url,
)
slice = Slice.objects.create(
project=project,
name=slice_name,
description=slice_desc,
owner=self.su,
)
tl["slice"] = slice
# To avoid expensive key creation
info = GENISliceInfo.objects.get(slice=slice)
info.ssh_private_key = "abc"
info.ssh_public_key = "def"
info.save()
slice_add_agg_url = reverse("slice_add_agg", args=[slice.id])
# add aggregate to slice
gopenflow_aggregate_slice_add_url = reverse(
"gopenflow_aggregate_slice_add",
kwargs={
"agg_id": agg.id,
"slice_id": slice.id,
})
# post the form to add aggregate to slice
response = self.client.post(
path=slice_add_agg_url,
data={"id": agg.id},
)
# should go the openflow special add aggregates page
self.assertRedirects(
response,
gopenflow_aggregate_slice_add_url + "?next=" + slice_add_agg_url,
)
# Set the slice info
response = test_get_and_post_form(self.client,
gopenflow_aggregate_slice_add_url +
"?next=" + slice_add_agg_url,
params=dict(
controller_url="tcp:blabla:6633",
password="******",
))
self.assertRedirects(
response,
slice_add_agg_url,
)
self.assertEqual(slice.aggregates.count(), 1,
"Did not add aggregate to slice.")
# select ports and switches
random.seed(0)
fs1_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs1_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
fs2_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs2_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
def create_port_slivers(fs, ports):
slivers = []
for p in ports:
slivers.append(
OpenFlowInterfaceSliver.objects.create(slice=slice,
resource=p))
kw = {}
for k, r in fs.items():
if r[0]:
kw[k + "_start"] = r[0]
if r[1]:
kw[k + "_end"] = r[1]
rule = FlowSpaceRule.objects.create(**kw)
for s in slivers:
rule.slivers.add(s)
return rule
# create the slivers for the slice
r1 = create_port_slivers(fs1, fs1_ports)
r2 = create_port_slivers(fs2, fs2_ports)
create_or_update(
OpenFlowSliceInfo,
filter_attrs=dict(slice=slice),
new_attrs=dict(password=password, controller_url=controller_url),
)
def add_switch_slivers(rule, switches):
for s in switches:
ports = OpenFlowInterface.objects.filter(switch=s)
for p in ports:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice, resource=p)
rule.slivers.add(sliver)
add_switch_slivers(r1, fs1_switches)
add_switch_slivers(r2, fs2_switches)
# get the expected reservation rspec
exp_rspec = create_resv_rspec(self.su, slice)
slice.start(self.su)
actual_rspec = DummyOFAggregate.objects.all()[0].resv_rspec
self.assertEqual(exp_rspec, actual_rspec)
def test_gapi_CreateSliver(self,
proj_name = "test project",
proj_desc = "test project description",
slice_name = "test slice",
slice_desc = "test slice description",
username = "******",
firstname = "gapi",
lastname = "user",
password = "******",
affiliation = "Stanford",
email = "*****@*****.**",
controller_url = "tcp:bla.com:6633",
fs1 = dict(
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(4455, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
),
fs2 = dict(
dl_src=("11:22:33:44:55:66", "11:22:33:44:55:77"),
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(None, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
nw_proto=(4,4),
tp_src=(123,123),
),
slice=None,
expiration=datetime.now() + timedelta(days=1),
create_aggregates=True,
):
# IMPORTANT: If you change fs1 and fs2, make sure that
# the rspec for fs1 is shorter than that for fs2 since
# the test needs to order them by length.
# add the aggregates
if create_aggregates:
self.test_create_aggregates()
self.client.logout()
# setup threadlocals
tl = threadlocals.get_thread_locals()
tl["user"] = self.su
# create the info
user, _ = create_or_update(
model=User,
filter_attrs={"username": username},
new_attrs={
"first_name": firstname,
"last_name": lastname,
"email": email,
}
)
create_or_update(UserProfile,
filter_attrs={
"user": user,
},
new_attrs={
"affiliation":affiliation,
}
)
if slice:
project = slice.project
project.name = proj_name
project.description = proj_desc
project.save()
else:
project, _ = create_or_update(Project,
filter_attrs=dict(name=proj_name),
new_attrs=dict(description=proj_desc),
)
if not slice:
slice = Slice.objects.create(
project=project,
name=slice_name,
description=slice_desc,
owner=user,
expiration_date=expiration,
)
# select ports and switches
random.seed(0)
fs1_switches = random.sample(list(OpenFlowSwitch.objects.all()), 10)
fs1_ports = random.sample(list(OpenFlowInterface.objects.all()), 10)
fs2_switches = random.sample(list(OpenFlowSwitch.objects.all()), 10)
fs2_ports = random.sample(list(OpenFlowInterface.objects.all()), 10)
if slice:
OpenFlowInterfaceSliver.objects.filter(
slice=slice).delete()
FlowSpaceRule.objects.filter(slivers__slice=slice).delete()
def create_port_slivers(fs, ports):
slivers = []
for p in ports:
slivers.append(OpenFlowInterfaceSliver.objects.create(
slice=slice, resource=p))
kw = {}
for k, r in fs.items():
if r[0]:
kw[k+"_start"] = r[0]
if r[1]:
kw[k+"_end"] = r[1]
rule = FlowSpaceRule.objects.create(**kw)
for s in slivers:
rule.slivers.add(s)
return rule
# create the slivers for the slice
r1 = create_port_slivers(fs1, fs1_ports)
r2 = create_port_slivers(fs2, fs2_ports)
create_or_update(OpenFlowSliceInfo,
filter_attrs=dict(slice=slice),
new_attrs=dict(password=password, controller_url=controller_url),
)
# get the rspec using only the ports
resv_rspec = rspec_mod.create_resv_rspec(user, slice)
# add the full switches to the reservation rspec
root = et.fromstring(resv_rspec)
fs_elems = root.findall(".//%s" % rspec_mod.FLOWSPACE_TAG)
def add_switches(elem, switches):
for s in switches:
et.SubElement(
elem, rspec_mod.SWITCH_TAG, {
rspec_mod.URN: rspec_mod._dpid_to_urn(s.datapath_id),
},
)
add_switches(fs_elems[0], fs1_switches)
add_switches(fs_elems[1], fs2_switches)
resv_rspec = et.tostring(root)
# Now add the switches into the slice and get the expected rspec
# that will be returned
def add_switch_slivers(rule, switches):
for s in switches:
ports = OpenFlowInterface.objects.filter(switch=s)
for p in ports:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice, resource=p)
rule.slivers.add(sliver)
add_switch_slivers(r1, fs1_switches)
add_switch_slivers(r2, fs2_switches)
expected_resv_rspec = rspec_mod.create_resv_rspec(user, slice)
# delete created state
project.delete()
user.delete()
r1.delete()
r2.delete()
# create the slice using gapi
ret_rspec = self.rpc.CreateSliver(
self.slice_gid.get_urn(),
[self.slice_cred],
resv_rspec,
{},
)
ret = order_rspec(ret_rspec)
exp = order_rspec(expected_resv_rspec)
self.assertEqual(
ret,
exp,
"Expected:\n%s \nFound:\n%s" % (exp, ret),
)
# check that the created state is what is expected
self.assertEqual(
GENISliceInfo.objects.all()[0].slice_urn, self.slice_gid.get_urn())
project = Project.objects.all()[0]
self.assertEqual(project.name, proj_name)
self.assertEqual(project.description, proj_desc)
slice = Slice.objects.all()[0]
self.assertEqual(slice.name, slice_name)
self.assertEqual(slice.description, slice_desc)
self.assertEqual(slice.project, project)
self.assertEqual(
long(time.mktime(slice.expiration_date.timetuple())),
long(time.mktime(expiration.timetuple())),
)
user = User.objects.get(username=username)
self.assertEqual(user.first_name, firstname)
self.assertEqual(user.last_name, lastname)
self.assertEqual(user.email, email)
user_profile= UserProfile.objects.all()[0]
self.assertEqual(user_profile.affiliation, affiliation)
self.assertEqual(user, user)
r1 = FlowSpaceRule.objects.all()[0]
r2 = FlowSpaceRule.objects.all()[1]
def verif_rule(r, fs):
for field in "dl_src", "dl_dst", "dl_type", \
"vlan_id", "nw_src", "nw_dst", "nw_proto", \
"tp_src", "tp_dst":
if field in fs:
self.assertEqual(fs[field][0], getattr(r, field+"_start"))
self.assertEqual(fs[field][1], getattr(r, field+"_end"))
else:
self.assertEqual(None, getattr(r, field+"_start"))
self.assertEqual(None, getattr(r, field+"_end"))
verif_rule(r1, fs1)
verif_rule(r2, fs2)
# check the slivers in rules: make sure each rule has all the
# the interfaces it is supposed to have.
def verif_slivers(r, ports, switches):
all_ports = []
all_ports.extend(ports)
for s in switches:
all_ports.extend(OpenFlowInterface.objects.filter(switch=s))
all_ports = set(all_ports)
# check number of interfaces
self.assertEqual(len(all_ports), r.slivers.count())
# check slivers
for sliver in r.slivers.all():
self.assertTrue(sliver.resource.as_leaf_class() in all_ports)
verif_slivers(r1, fs1_ports, fs1_switches)
verif_slivers(r2, fs2_ports, fs2_switches)
return ret_rspec
def test_gapi_CreateSliver(
self,
proj_name="test project",
proj_desc="test project description",
slice_name="test slice",
slice_desc="test slice description",
username="******",
firstname="gapi",
lastname="user",
password="******",
affiliation="Stanford",
email="*****@*****.**",
controller_url="tcp:bla.com:6633",
fs1=dict(
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(4455, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
),
fs2=dict(
dl_src=("11:22:33:44:55:66", "11:22:33:44:55:77"),
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(None, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
nw_proto=(4, 4),
tp_src=(123, 123),
),
slice=None,
expiration=datetime.now() + timedelta(days=1),
create_aggregates=True,
):
# IMPORTANT: If you change fs1 and fs2, make sure that
# the rspec for fs1 is shorter than that for fs2 since
# the test needs to order them by length.
# add the aggregates
if create_aggregates:
self.test_create_aggregates()
self.client.logout()
# setup threadlocals
tl = threadlocals.get_thread_locals()
tl["user"] = self.su
# create the info
user, _ = create_or_update(model=User,
filter_attrs={"username": username},
new_attrs={
"first_name": firstname,
"last_name": lastname,
"email": email,
})
create_or_update(UserProfile,
filter_attrs={
"user": user,
},
new_attrs={
"affiliation": affiliation,
})
if slice:
project = slice.project
project.name = proj_name
project.description = proj_desc
project.save()
else:
project, _ = create_or_update(
Project,
filter_attrs=dict(name=proj_name),
new_attrs=dict(description=proj_desc),
)
if not slice:
slice = Slice.objects.create(
project=project,
name=slice_name,
description=slice_desc,
owner=user,
expiration_date=expiration,
)
# select ports and switches
random.seed(0)
fs1_switches = random.sample(list(OpenFlowSwitch.objects.all()), 10)
fs1_ports = random.sample(list(OpenFlowInterface.objects.all()), 10)
fs2_switches = random.sample(list(OpenFlowSwitch.objects.all()), 10)
fs2_ports = random.sample(list(OpenFlowInterface.objects.all()), 10)
if slice:
OpenFlowInterfaceSliver.objects.filter(slice=slice).delete()
FlowSpaceRule.objects.filter(slivers__slice=slice).delete()
def create_port_slivers(fs, ports):
slivers = []
for p in ports:
slivers.append(
OpenFlowInterfaceSliver.objects.create(slice=slice,
resource=p))
kw = {}
for k, r in fs.items():
if r[0]: kw[k + "_start"] = r[0]
if r[1]: kw[k + "_end"] = r[1]
rule = FlowSpaceRule.objects.create(**kw)
for s in slivers:
rule.slivers.add(s)
return rule
# create the slivers for the slice
r1 = create_port_slivers(fs1, fs1_ports)
r2 = create_port_slivers(fs2, fs2_ports)
create_or_update(
OpenFlowSliceInfo,
filter_attrs=dict(slice=slice),
new_attrs=dict(password=password, controller_url=controller_url),
)
# get the rspec using only the ports
resv_rspec = rspec_mod.create_resv_rspec(user, slice)
# add the full switches to the reservation rspec
root = et.fromstring(resv_rspec)
fs_elems = root.findall(".//%s" % rspec_mod.FLOWSPACE_TAG)
def add_switches(elem, switches):
for s in switches:
et.SubElement(
elem,
rspec_mod.SWITCH_TAG,
{
rspec_mod.URN: rspec_mod._dpid_to_urn(s.datapath_id),
},
)
add_switches(fs_elems[0], fs1_switches)
add_switches(fs_elems[1], fs2_switches)
resv_rspec = et.tostring(root)
# Now add the switches into the slice and get the expected rspec
# that will be returned
def add_switch_slivers(rule, switches):
for s in switches:
ports = OpenFlowInterface.objects.filter(switch=s)
for p in ports:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice, resource=p)
rule.slivers.add(sliver)
add_switch_slivers(r1, fs1_switches)
add_switch_slivers(r2, fs2_switches)
expected_resv_rspec = rspec_mod.create_resv_rspec(user, slice)
# delete created state
project.delete()
user.delete()
r1.delete()
r2.delete()
# create the slice using gapi
ret_rspec = self.rpc.CreateSliver(
self.slice_gid.get_urn(),
[self.slice_cred],
resv_rspec,
{},
)
ret = order_rspec(ret_rspec)
exp = order_rspec(expected_resv_rspec)
self.assertEqual(
ret,
exp,
"Expected:\n%s \nFound:\n%s" % (exp, ret),
)
# check that the created state is what is expected
self.assertEqual(GENISliceInfo.objects.all()[0].slice_urn,
self.slice_gid.get_urn())
project = Project.objects.all()[0]
self.assertEqual(project.name, proj_name)
self.assertEqual(project.description, proj_desc)
slice = Slice.objects.all()[0]
self.assertEqual(slice.name, slice_name)
self.assertEqual(slice.description, slice_desc)
self.assertEqual(slice.project, project)
self.assertEqual(
long(time.mktime(slice.expiration_date.timetuple())),
long(time.mktime(expiration.timetuple())),
)
user = User.objects.get(username=username)
self.assertEqual(user.first_name, firstname)
self.assertEqual(user.last_name, lastname)
self.assertEqual(user.email, email)
user_profile = UserProfile.objects.all()[0]
self.assertEqual(user_profile.affiliation, affiliation)
self.assertEqual(user, user)
r1 = FlowSpaceRule.objects.all()[0]
r2 = FlowSpaceRule.objects.all()[1]
def verif_rule(r, fs):
for field in "dl_src", "dl_dst", "dl_type", \
"vlan_id", "nw_src", "nw_dst", "nw_proto", \
"tp_src", "tp_dst":
if field in fs:
self.assertEqual(fs[field][0],
getattr(r, field + "_start"))
self.assertEqual(fs[field][1], getattr(r, field + "_end"))
else:
self.assertEqual(None, getattr(r, field + "_start"))
self.assertEqual(None, getattr(r, field + "_end"))
verif_rule(r1, fs1)
verif_rule(r2, fs2)
# check the slivers in rules: make sure each rule has all the
# the interfaces it is supposed to have.
def verif_slivers(r, ports, switches):
all_ports = []
all_ports.extend(ports)
for s in switches:
all_ports.extend(OpenFlowInterface.objects.filter(switch=s))
all_ports = set(all_ports)
# check number of interfaces
self.assertEqual(len(all_ports), r.slivers.count())
# check slivers
for sliver in r.slivers.all():
self.assertTrue(sliver.resource.as_leaf_class() in all_ports)
verif_slivers(r1, fs1_ports, fs1_switches)
verif_slivers(r2, fs2_ports, fs2_switches)
return ret_rspec
def _to_rspec(self, slice):
"""
See L{GENIAggregate._to_rspec}.
"""
user = threadlocals.get_thread_locals()["user"]
return create_resv_rspec(user, slice, aggregate=self)
def download_resv_rspec(request, slice_id):
slice = get_object_or_404(Slice, pk=slice_id)
rspec = create_resv_rspec(request.user, slice)
response = HttpResponse(rspec, mimetype='application/force-download')
response['Content-Disposition'] = 'attachment; filename=resv_rspec.xml'
return response
def test_reserve_sliver(self):
self.test_add_aggregate()
proj_name = "test project"
proj_desc = "test project description"
slice_name = "test slice"
slice_desc = "test slice description"
username = "******"
firstname = "gapi"
lastname = "user"
password = "******"
affiliation = "Stanford"
email = "*****@*****.**"
controller_url = "tcp:bla.com:6633"
fs1 = dict(
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(4455, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
)
fs2 = dict(
dl_src=("11:22:33:44:55:66", "11:22:33:44:55:77"),
dl_dst=("11:22:33:44:55:66", None),
dl_type=(1234, 1236),
vlan_id=(None, 4455),
nw_src=("123.123.132.123", "222.222.222.222"),
nw_proto=(4,4),
tp_src=(123,123),
)
agg = GCFOpenFlowAggregate.objects.all()[0]
# setup threadlocals
tl = threadlocals.get_thread_locals()
tl["user"] = self.su
project = Project.objects.create(
name=proj_name, description=proj_desc,
)
tl["project"] = project
url = reverse("project_add_agg", args=[project.id])
response = self.client.post(
path=url,
data={"id": agg.id},
)
self.assertTrue(project.aggregates.count() == 1)
self.assertRedirects(
response,
url,
)
slice = Slice.objects.create(
project=project,
name=slice_name,
description=slice_desc,
owner=self.su,
)
tl["slice"] = slice
# To avoid expensive key creation
info = GENISliceInfo.objects.get(slice=slice)
info.ssh_private_key="abc"
info.ssh_public_key = "def"
info.save()
slice_add_agg_url = reverse("slice_add_agg", args=[slice.id])
# add aggregate to slice
gopenflow_aggregate_slice_add_url = reverse(
"gopenflow_aggregate_slice_add",
kwargs={
"agg_id": agg.id,
"slice_id": slice.id,
}
)
# post the form to add aggregate to slice
response = self.client.post(
path=slice_add_agg_url,
data={"id": agg.id},
)
# should go the openflow special add aggregates page
self.assertRedirects(
response,
gopenflow_aggregate_slice_add_url + "?next=" + slice_add_agg_url,
)
# Set the slice info
response = test_get_and_post_form(
self.client,
gopenflow_aggregate_slice_add_url+ "?next=" + slice_add_agg_url,
params=dict(
controller_url="tcp:blabla:6633",
password="******",
)
)
self.assertRedirects(
response,
slice_add_agg_url,
)
self.assertEqual(
slice.aggregates.count(), 1,
"Did not add aggregate to slice.")
# select ports and switches
random.seed(0)
fs1_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs1_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
fs2_switches = random.sample(list(OpenFlowSwitch.objects.all()), 2)
fs2_ports = random.sample(list(OpenFlowInterface.objects.all()), 2)
def create_port_slivers(fs, ports):
slivers = []
for p in ports:
slivers.append(OpenFlowInterfaceSliver.objects.create(
slice=slice, resource=p))
kw = {}
for k, r in fs.items():
if r[0]:
kw[k+"_start"] = r[0]
if r[1]:
kw[k+"_end"] = r[1]
rule = FlowSpaceRule.objects.create(**kw)
for s in slivers:
rule.slivers.add(s)
return rule
# create the slivers for the slice
r1 = create_port_slivers(fs1, fs1_ports)
r2 = create_port_slivers(fs2, fs2_ports)
create_or_update(OpenFlowSliceInfo,
filter_attrs=dict(slice=slice),
new_attrs=dict(password=password, controller_url=controller_url),
)
def add_switch_slivers(rule, switches):
for s in switches:
ports = OpenFlowInterface.objects.filter(switch=s)
for p in ports:
sliver, _ = OpenFlowInterfaceSliver.objects.get_or_create(
slice=slice, resource=p)
rule.slivers.add(sliver)
add_switch_slivers(r1, fs1_switches)
add_switch_slivers(r2, fs2_switches)
# get the expected reservation rspec
exp_rspec = create_resv_rspec(self.su, slice)
slice.start(self.su)
actual_rspec = DummyOFAggregate.objects.all()[0].resv_rspec
self.assertEqual(exp_rspec, actual_rspec)
