def test_UserOptIn2(self):
"""
Test a user opting in.
"""
from expedient.common.tests.client import Browser
from openflow.optin_manager.opts.models import Experiment,ExperimentFLowSpace
import random
slices = self.fv_clients[0].api.listSlices()
self.assertEqual(len(slices), 1) # root
# get the resources
slice_urn, cred = self.create_ch_slice()
options = dict(geni_compressed=False, geni_available=True)
rspec = self.am_client.ListResources(cred, options)
# Create switches and links
switches, links = parse_rspec(rspec)
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="******")
for switch in switches:
exp_ip_src_s = random.randint(0,0x80000000) & 0xFFFF0000
exp_ip_src_e = random.randint(0x80000000,0xFFFFFFFF) & 0xFFFF0000
ExperimentFLowSpace.objects.create(exp=exp, dpid=switch.dpid,
ip_src_s=exp_ip_src_s,
ip_src_e=exp_ip_src_e,
)
logger.debug("Done creating sliver")
# Get user to opt in
logger.debug("Logging into browser")
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")
logger.debug("Login success")
# drop_to_shell(local=locals())
f = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_in"%
(test_settings.HOST, test_settings.OM_PORT),
dict(experiment=1))
logger.debug("Posted opt-in request, reading response.")
res = f.read()
self.assertEqual(f.code, 200)
self.assertTrue("successfully" in res, "Did not get successful opt in message: %s" % res)
logger.debug("Response fine, opting out.")
# now test opt out:
f = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_out"%
(test_settings.HOST, test_settings.OM_PORT),
{"1":"checked"})
res = f.read()
self.assertEqual(f.code, 200)
self.assertTrue("Successful" in res, "Returned %s"%res)
def test_UserOptIn1(self):
"""
Test a user opting in.
"""
from expedient.common.tests.client import Browser
#create an experiment through CH
self.create_sliver_core(fs_randomness=False)
logger.debug("Done creating sliver")
# Get user to opt in
logger.debug("Logging into browser")
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")
logger.debug("Login success")
# drop_to_shell(local=locals())
f = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_in"%
(test_settings.HOST, test_settings.OM_PORT),
dict(experiment=1))
logger.debug("Posted opt-in request, reading response.")
res = f.read()
self.assertEqual(f.code, 200)
self.assertTrue("successfully" in res, "Did not get successful opt in message: %s" % res)
# test if FV has the expected flowspace match entries
from expedient.common.tests.utils import run_cmd
fvctl = run_cmd(
"sh %s/scripts/fvctl.sh listFlowSpace" % (
test_settings.FLOWVISOR_DIR,
),
)
data = fvctl.communicate(input="rootpassword")
fv_rules = data[0].split("\n")
print(fv_rules)
#for fv_rule in fv_rules
logger.debug("Response fine, opting out.")
# now test opt out:
f = b.get_and_post_form(SCHEME+"://%s:%s/opts/opt_out"%
(test_settings.HOST, test_settings.OM_PORT),
{"1":"checked"})
res = f.read()
self.assertEqual(f.code, 200)
self.assertTrue("Successful" in res, "Returned %s"%res)
def prepare_ch(self, proj_dir, ch_host, ch_port, ch_username, ch_passwd,
om_host, om_port):
"""
Flush and prepare the CH DB.
Add the OMs to the CH.
"""
from os.path import dirname
subprocess.call(shlex.split(
"python %s/manage.py flush --noinput" % proj_dir))
subprocess.call(shlex.split(
"python %s/manage.py syncdb --noinput" % proj_dir))
subprocess.call(shlex.split(
"python %s/manage.py createsuperuser --noinput "
"--username=expedient [email protected]" % proj_dir))
subprocess.call(shlex.split(
"python %s/manage.py set_fake_passwords"
" --password=expedient" % proj_dir))
browser = Browser()
browser.login(
SCHEME+"://%s:%s%s" % (
ch_host, ch_port, "/accounts/login/"),
"expedient", "expedient")
response = browser.get_and_post_form(
url=SCHEME+"://%s:%s%s" % (
ch_host, ch_port, "/openflow/aggregate/create/"),
params=dict(
name="Test OM",
description="TestOM Description",
location="Stanford, CA",
usage_agreement="Do you agree?",
username=ch_username,
password=ch_passwd,
url=SCHEME+"://%s:%s%s" % (
om_host, om_port, "/xmlrpc/xmlrpc/"),
),
del_params=["verify_certs"],
)
self.assertTrue(
response.geturl() == \
SCHEME+"://%s:%s%s" % (
ch_host, ch_port, "/openflow/aggregate/1/links/"),
"Did not redirect after create correctly. Response was: %s"
% response.read(),
)
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()
