def accept_user_fs_request(fs_request):
'''
accepts a user flowspace request and adds it to user flowpscae.
If a previous user flowspace is subset of what is being accepted, replace it
with new flowpsace only to avoid duplicate.
@param fs_request: flowspace request to be accepted
@type fs_request: list of RequestedUserFlowSpace
@return: [fv_args,match_list] to be xmlrpc-called to fv
@note: all fs_requests should belong to one user
'''
if len(fs_request) == 0:
return [[], []]
#check which of the previous user flowspaces are a subset of this flowspace
ufs = UserFlowSpace.objects.filter(user=fs_request[0].user)
for fs in ufs:
if (singlefs_is_subset_of(fs, fs_request)):
fs.delete()
for single_fs in fs_request:
user = single_fs.user
ufs = UserFlowSpace(user=single_fs.user, approver=single_fs.admin)
copy_fs(single_fs, ufs)
ufs.save()
single_fs.delete()
[fv_args, match_list] = update_user_opts(user)
return [fv_args, match_list]
def accept_user_fs_request(fs_request):
'''
accepts a user flowspace request and adds it to user flowpscae.
If a previous user flowspace is subset of what is being accepted, replace it
with new flowpsace only to avoid duplicate.
@param fs_request: flowspace request to be accepted
@type fs_request: list of RequestedUserFlowSpace
@return: [fv_args,match_list] to be xmlrpc-called to fv
@note: all fs_requests should belong to one user
'''
if len(fs_request) == 0:
return [[],[]]
#check which of the previous user flowspaces are a subset of this flowspace
ufs = UserFlowSpace.objects.filter(user=fs_request[0].user)
for fs in ufs:
if (singlefs_is_subset_of(fs,fs_request)):
fs.delete()
for single_fs in fs_request:
user = single_fs.user
ufs = UserFlowSpace(user=single_fs.user, approver=single_fs.admin)
copy_fs(single_fs,ufs)
ufs.save()
single_fs.delete()
[fv_args,match_list] = update_user_opts(user)
return [fv_args,match_list]
def test_case1(self):
from django.contrib.auth.models import User
from openflow.optin_manager.opts.models import UserFlowSpace,Experiment, ExperimentFLowSpace
# create a second experiemnt
username = "******"
password = "******"
u = User.objects.create(username=username, is_active=True)
u.set_password(password)
u.save()
self.user_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.user_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
#assign flowspace to user
adm = User.objects.get(username="******")
ufs = UserFlowSpace(user=u, ip_src_s=self.user_ip_src_s,
ip_src_e=self.user_ip_src_e,approver=adm)
ufs.save()
Experiment.objects.all().delete()
ExperimentFLowSpace.objects.all().delete()
exp = Experiment.objects.create(slice_id="first_id", project_name="first_project",
project_desc="project description", slice_name="first slice",
slice_desc="slice description", controller_url="http://controller.com",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:01",
ip_src_s=0x05866000,
ip_src_e=0xa0000000,
)
exp = Experiment.objects.create(slice_id="second_id", project_name="second_project",
project_desc="project description", slice_name="second slice",
slice_desc="slice description", controller_url="http://controller.com",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:02",
ip_src_s=0x00123456,
ip_src_e=0x90123456,
)
exp = Experiment.objects.create(slice_id="third_id", project_name="third_project",
project_desc="project description", slice_name="third slice",
slice_desc="slice description", controller_url="http://controller.com",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:03",
ip_src_s=0x00333456,
ip_src_e=0x95123456,
)
def prepare_om(self, proj_dir, flowvisor, ch_username, ch_passwd):
"""
Flush the OM DB and add a flowvisor and user for the CH
"""
call_env_command(proj_dir, "flush",
interactive=False)
self.om_env = Env(proj_dir)
self.om_env.switch_to()
from django.contrib.auth.models import User
from openflow.optin_manager.users.models import UserProfile
from openflow.optin_manager.xmlrpc_server.models import FVServerProxy
from openflow.optin_manager.xmlrpc_server.ch_api import om_ch_translate
from openflow.optin_manager.opts.models import AdminFlowSpace, UserFlowSpace
import random
# Create the Expedient user
u = User.objects.create(username=ch_username)
u.set_password(ch_passwd)
u.save()
profile = UserProfile.get_or_create_profile(u)
profile.is_clearinghouse_user = True
profile.save()
# make a normal user on system
username = "******"
password = "******"
u = User.objects.create(username=username, is_active=True)
u.set_password(password)
u.save()
# assign flowspace to the user
random.seed(0)
self.user_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.user_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
fields=["dl_src","dl_dst","vlan_id","tp_src","tp_dst"]
random.shuffle(fields)
(to_str,from_str,width,om_name,of_name) = om_ch_translate.attr_funcs[fields[0]]
self.user_field_name = om_name
self.user_field_s = random.randint(0,2**(width)-3)
self.user_field_e = self.user_field_s + 1
# assign full flowspace to admin:
username = "******"
password = "******"
adm = User.objects.create(username=username, is_superuser=True,
is_staff=True, is_active=True)
adm.set_password(password)
adm.save()
profile = UserProfile.get_or_create_profile(adm)
profile.is_net_admin = True
profile.supervisor = adm
profile.max_priority_level = 7000
profile.save()
AdminFlowSpace.objects.create(user=adm)
# assign flowspace to user
ufs = UserFlowSpace(user=u, ip_src_s=self.user_ip_src_s,
ip_src_e=self.user_ip_src_e,approver=adm)
setattr(ufs,"%s_s"%self.user_field_name,self.user_field_s)
setattr(ufs,"%s_e"%self.user_field_name,self.user_field_e)
ufs.save()
# Create the FV proxy connection
fv = FVServerProxy(
name="Flowvisor",
username=flowvisor["username"],
password=flowvisor["password"],
url="https://%s:%s/xmlrpc" % (
flowvisor["host"], flowvisor["xmlrpc_port"],
),
verify_certs=False,
)
fv.save()
self.om_client = xmlrpclib.ServerProxy(
SCHEME+"://%s:%s@%s:%s/xmlrpc/xmlrpc/" % (
ch_username, ch_passwd,
test_settings.HOST, test_settings.OM_PORT,
)
)
self.om_env.switch_from()
def test_optin(self):
from expedient.common.tests.client import Browser
from openflow.optin_manager.opts.models import UserOpts, OptsFlowSpace
from openflow.optin_manager.opts.models import AdminFlowSpace, UserFlowSpace,Experiment, ExperimentFLowSpace
from django.contrib.auth.models import User
#make a normal user on system
username = "******"
password = "******"
u = User.objects.create(username=username, is_active=True)
u.set_password(password)
u.save()
#assign a flowspace to the user and experiment
self.user_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.user_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
self.exp_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.exp_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
fields=["dl_src","dl_dst","vlan_id","tp_src","tp_dst"]
random.shuffle(fields)
from openflow.optin_manager.xmlrpc_server.ch_api import om_ch_translate
(to_str,from_str,width,om_name,of_name) = om_ch_translate.attr_funcs[fields[0]]
self.user_field_name = om_name
self.user_field_s = random.randint(0,2**width-3)
self.user_field_e = self.user_field_s + 1
(to_str,from_str,width,om_name,of_name) = om_ch_translate.attr_funcs[fields[1]]
self.exp_field_name = om_name
self.exp_field_s = random.randint(0,2**width-3)
self.exp_field_e = self.exp_field_s + 1
# assign full flowspace to admin:
adm = User.objects.get(username="******")
AdminFlowSpace.objects.create(user=adm)
#assign flowspace to user
ufs = UserFlowSpace(user=u, ip_src_s=self.user_ip_src_s,
ip_src_e=self.user_ip_src_e,approver=adm)
setattr(ufs,"%s_s"%self.user_field_name,self.user_field_s)
setattr(ufs,"%s_e"%self.user_field_name,self.user_field_e)
ufs.save()
#create an experiment and assign a flowspace to it
exp = Experiment.objects.create(slice_id="slice_id", project_name="project name",
project_desc="project description", slice_name="slice name",
slice_desc="slice description", controller_url="controller url",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:01",
ip_src_s=self.exp_ip_src_s,
ip_src_e=self.exp_ip_src_e,
)
setattr(expfs,"%s_s"%self.exp_field_name,self.exp_field_s)
setattr(expfs,"%s_e"%self.exp_field_name,self.exp_field_e)
expfs.save()
# First authenticate
b = Browser()
logged_in = b.login(SCHEME+"://%s:%s/accounts/login/"%
(test_settings.HOST, test_settings.OM_PORT),
"user","password")
self.assertTrue(logged_in,"Could not log in")
g = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_in"%
(test_settings.HOST, test_settings.OM_PORT),
dict(experiment=1))
uopt = UserOpts.objects.filter(user__username__exact="user")[0]
self.assertEqual(uopt.priority , 1)
optfs = OptsFlowSpace.objects.filter(opt = uopt)[0]
self.assertEqual(optfs.ip_src_s , max(self.user_ip_src_s,self.exp_ip_src_s))
self.assertEqual(optfs.ip_src_e , min(self.user_ip_src_e,self.exp_ip_src_e))
self.assertEqual(getattr(optfs,"%s_s"%self.user_field_name), self.user_field_s)
self.assertEqual(getattr(optfs,"%s_e"%self.user_field_name), self.user_field_e)
self.assertEqual(getattr(optfs,"%s_s"%self.exp_field_name), self.exp_field_s)
self.assertEqual(getattr(optfs,"%s_e"%self.exp_field_name), self.exp_field_e)
# now test opt out:
g = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_out"%
(test_settings.HOST, test_settings.OM_PORT),
{"1":"checked"})
optfs = OptsFlowSpace.objects.filter(opt = uopt)
self.assertEqual(optfs.count(),0)
self.create_more_exps()
def setUp(self):
# Create a test user
self.test_user = User.objects.create_user(
"user", "*****@*****.**", "password")
profile = UserProfile.get_or_create_profile(self.test_user)
# Create a test admin
self.test_admin = User.objects.create_superuser(
"admin", "*****@*****.**", "password")
# Assign a flowpsace to uer
self.user_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.user_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
# Assign a flowpsace to experiment
self.exp_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
self.exp_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
# Choose a random field
fields=["dl_src","dl_dst","vlan_id","tp_src","tp_dst"]
random.shuffle(fields)
(to_str,from_str,width,om_name,of_name) = om_ch_translate.attr_funcs[fields[0]]
self.user_field_name = om_name
self.user_field_s = random.randint(0,2**width-3)
self.user_field_e = self.user_field_s + 1
(to_str,from_str,width,om_name,of_name) = om_ch_translate.attr_funcs[fields[1]]
self.exp_field_name = om_name
self.exp_field_s = random.randint(0,2**width-3)
self.exp_field_e = self.exp_field_s + 1
#save flowspace for user
ufs = UserFlowSpace(user=self.test_user, ip_src_s=self.user_ip_src_s,
ip_src_e=self.user_ip_src_e,approver=self.test_admin)
setattr(ufs,"%s_s"%self.user_field_name,self.user_field_s)
setattr(ufs,"%s_e"%self.user_field_name,self.user_field_e)
ufs.save()
#create an experiment and assign a flowspace to it
exp = Experiment.objects.create(slice_id="slice_id_1", project_name="project name_1",
project_desc="project description", slice_name="slice name_1",
slice_desc="slice description", controller_url="controller url",
owner_email="owner email", owner_password="******")
expfs = ExperimentFLowSpace.objects.create(exp=exp, dpid="00:00:00:00:00:00:01",
ip_src_s=self.exp_ip_src_s,
ip_src_e=self.exp_ip_src_e,
)
setattr(expfs,"%s_s"%self.exp_field_name,self.exp_field_s)
setattr(expfs,"%s_e"%self.exp_field_name,self.exp_field_e)
expfs.save()
# Create dummy FV
fv = DummyFV.objects.create()
# Load up a fake topology in the Dummy FV
fv.populateTopology(10, 20, use_random=USE_RANDOM)
# create fake users for the Dummy FV
username = "******"
password = "******"
u = User.objects.create(username=username)
u.set_password(password)
u.save()
# Create the FV proxy connection
FVServerProxy.objects.create(
name="Flowvisor",
username=username,
password=password,
url = SCHEME+"://%s:8443/dummyfv/%d/xmlrpc/" % (
HOST,fv.id,
),
)
#Login
logged = self.client.login(username="******",password="******")
self.assertEqual(logged,True)
def setUp(self):
# Create a test user
self.test_user = User.objects.create_user("user", "*****@*****.**",
"password")
profile = UserProfile.get_or_create_profile(self.test_user)
# Create a test admin
self.test_admin = User.objects.create_superuser(
"admin", "*****@*****.**", "password")
# Assign a flowpsace to uer
self.user_ip_src_s = random.randint(0, 0x80000000) & 0xFFFF0000
self.user_ip_src_e = random.randint(0x80000000,
0xFFFFFFFF) & 0xFFFF0000
# Assign a flowpsace to experiment
self.exp_ip_src_s = random.randint(0, 0x80000000) & 0xFFFF0000
self.exp_ip_src_e = random.randint(0x80000000, 0xFFFFFFFF) & 0xFFFF0000
# Choose a random field
fields = ["dl_src", "dl_dst", "vlan_id", "tp_src", "tp_dst"]
random.shuffle(fields)
(to_str, from_str, width, om_name,
of_name) = om_ch_translate.attr_funcs[fields[0]]
self.user_field_name = om_name
self.user_field_s = random.randint(0, 2**width - 3)
self.user_field_e = self.user_field_s + 1
(to_str, from_str, width, om_name,
of_name) = om_ch_translate.attr_funcs[fields[1]]
self.exp_field_name = om_name
self.exp_field_s = random.randint(0, 2**width - 3)
self.exp_field_e = self.exp_field_s + 1
#save flowspace for user
ufs = UserFlowSpace(user=self.test_user,
ip_src_s=self.user_ip_src_s,
ip_src_e=self.user_ip_src_e,
approver=self.test_admin)
setattr(ufs, "%s_s" % self.user_field_name, self.user_field_s)
setattr(ufs, "%s_e" % self.user_field_name, self.user_field_e)
ufs.save()
#create an experiment and assign a flowspace to it
exp = Experiment.objects.create(slice_id="slice_id_1",
project_name="project name_1",
project_desc="project description",
slice_name="slice name_1",
slice_desc="slice description",
controller_url="controller url",
owner_email="owner email",
owner_password="******")
expfs = ExperimentFLowSpace.objects.create(
exp=exp,
dpid="00:00:00:00:00:00:01",
ip_src_s=self.exp_ip_src_s,
ip_src_e=self.exp_ip_src_e,
)
setattr(expfs, "%s_s" % self.exp_field_name, self.exp_field_s)
setattr(expfs, "%s_e" % self.exp_field_name, self.exp_field_e)
expfs.save()
# Create dummy FV
fv = DummyFV.objects.create()
# Load up a fake topology in the Dummy FV
fv.populateTopology(10, 20, use_random=USE_RANDOM)
# create fake users for the Dummy FV
username = "******"
password = "******"
u = User.objects.create(username=username)
u.set_password(password)
u.save()
# Create the FV proxy connection
FVServerProxy.objects.create(
name="Flowvisor",
username=username,
password=password,
url=SCHEME + "://%s:8443/dummyfv/%d/xmlrpc/" % (
HOST,
fv.id,
),
)
#Login
logged = self.client.login(username="******", password="******")
self.assertEqual(logged, True)
