Exemple #1
0
class ManualTests(TestCase):
    
    def setUp(self):
        """
        Load up a DB for the OM.
        Create a client to talk to the OM.
        """
        
        
        call_env_command(test_settings.OM_PROJECT_DIR, "flush",
                         interactive=False)
        self.om_env = Env(test_settings.OM_PROJECT_DIR)
        self.om_env.switch_to()
        
        from openflow.optin_manager.dummyfv.models import DummyFV
        from openflow.optin_manager.xmlrpc_server.models import FVServerProxy
        from openflow.optin_manager.users.models import UserProfile, Priority
        from django.contrib.auth.models import User 

        # Create the clearinghouse user
        username = "******"
        password = "******"
        u = User.objects.create(username=username)
        u.set_password(password)
        u.save()
        
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_clearinghouse_user = True
        profile.save()
        self.om_client = xmlrpclib.ServerProxy(
            SCHEME + "://%s:%s@%s:%s/xmlrpc/xmlrpc/" % (
                username, password, test_settings.HOST, test_settings.OM_PORT
            )
        )
        
        #create admin user: use this to look at DBs through admin interface
        username = "******"
        password = "******"
        u = User.objects.create_superuser(username, "*****@*****.**", password)
        u.save()
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_net_admin = True
        profile.supervisor = u
        profile.max_priority_level = Priority.Aggregate_Admin
        profile.admin_position = "Stanford Aggregate Admin"
        profile.save()      
         
         
        # Create dummy FVs
        for i in range(test_settings.NUM_DUMMY_FVS):
            fv = DummyFV.objects.create()
            # Load up a fake topology in the Dummy FV
            fv.populateTopology(10, 20, use_random=test_settings.USE_RANDOM)
            
            # create fake users for the Dummy FV
            username = "******" % i
            password = "******"
            u = User.objects.create(username=username)
            u.set_password(password)
            u.save()

            # Create the FV proxy connection
            FVServerProxy.objects.create(
                name="Flowvisor %s" % i,
                username=username,
                password=password,
                url = "test://%s:%s/dummyfv/%s/xmlrpc/" % (
                    test_settings.HOST, 8000, fv.id,
                ),
            )
            
    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 test_case2(self):
        from django.contrib.auth.models import User
        from openflow.optin_manager.opts.models import UserFlowSpace,Experiment, ExperimentFLowSpace

      
        username = "******"
        password = "******"
        u = User.objects.create(username=username, is_active=True)
        u.set_password(password)
        u.save()

        adm = User.objects.get(username="******")

        
        username = "******"
        password = "******"
        u = User.objects.create(username=username, is_active=True)
        u.set_password(password)
        u.save()

        username = "******"
        password = "******"
        u = User.objects.create(username=username, is_active=True)
        u.set_password(password)
        u.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",
                            tp_src_s=80, 
                            tp_src_e=80, 
                             )  
        
        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, 
                             ) 
Exemple #2
0
    def setUp(self):
        """
        Load up a DB for the OM.
        Create a client to talk to the OM.
        """
        
        
        call_env_command(test_settings.OM_PROJECT_DIR, "flush",
                         interactive=False)
        self.om_env = Env(test_settings.OM_PROJECT_DIR)
        self.om_env.switch_to()
        
        from openflow.optin_manager.dummyfv.models import DummyFV
        from openflow.optin_manager.xmlrpc_server.models import FVServerProxy
        from openflow.optin_manager.users.models import UserProfile, Priority
        from django.contrib.auth.models import User 

        # Create the clearinghouse user
        username = "******"
        password = "******"
        u = User.objects.create(username=username)
        u.set_password(password)
        u.save()
        
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_clearinghouse_user = True
        profile.save()
        self.om_client = xmlrpclib.ServerProxy(
            SCHEME + "://%s:%s@%s:%s/xmlrpc/xmlrpc/" % (
                username, password, test_settings.HOST, test_settings.OM_PORT
            )
        )
        
        #create admin user: use this to look at DBs through admin interface
        username = "******"
        password = "******"
        u = User.objects.create_superuser(username, "*****@*****.**", password)
        u.save()
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_net_admin = True
        profile.supervisor = u
        profile.max_priority_level = Priority.Aggregate_Admin
        profile.admin_position = "Stanford Aggregate Admin"
        profile.save()      
         
         
        # Create dummy FVs
        for i in range(test_settings.NUM_DUMMY_FVS):
            fv = DummyFV.objects.create()
            # Load up a fake topology in the Dummy FV
            fv.populateTopology(10, 20, use_random=test_settings.USE_RANDOM)
            
            # create fake users for the Dummy FV
            username = "******" % i
            password = "******"
            u = User.objects.create(username=username)
            u.set_password(password)
            u.save()

            # Create the FV proxy connection
            FVServerProxy.objects.create(
                name="Flowvisor %s" % i,
                username=username,
                password=password,
                url = "test://%s:%s/dummyfv/%s/xmlrpc/" % (
                    test_settings.HOST, 8000, fv.id,
                ),
            )
Exemple #3
0
class FullIntegration(TestCase):
    MININET_TOPO = "tree,2"
    EXPECTED_NUM_SWITCHES = 3
    EXPECTED_NUM_LINKS = 4
    NOX_APPS = "pyswitch packetdump"

    def run_nox(self, mininet_vm, num, port_start):
        """
        Connect to the mininet_vm and run 'num' instances of nox as
        a pyswitch with packet dumping.
        """
        kill_client = SSHClientPlus.exec_command_plus(
            mininet_vm[0], "mininet", "mininet",
            "sudo kill `ps -ae | grep lt-nox_core | awk '{ print $1 }'`",
            port=mininet_vm[1],
        )
        kill_client.wait()
        
        self.nox_clients = []
        for i in xrange(num):
            port = port_start + i
            cmd = "cd noxcore/build/src; ./nox_core -i ptcp:%s %s" % (
                port, self.NOX_APPS,
            )
            client = SSHClientPlus.exec_command_plus(
                mininet_vm[0], "mininet", "mininet", cmd, port=mininet_vm[1],
            )

            self.nox_clients.append(client)
        
    def connect_networks(self, flowvisors, mininet_vms, switch="ovsk"):
        """
        Create a 2-switch, 2-host linear topology on each mininet vm
        Connect the switches to the FV.
        """
        num = min([len(flowvisors), len(mininet_vms)])
        
        self.mininet_vm_clients = []
        for i in xrange(num):
            logger.debug("Connecting to the mininet VM at %s:%s" % mininet_vms[i])
            cmd = "sudo mn --topo=%s "  % self.MININET_TOPO +\
                "--controller=remote --ip=%s --port=%s --mac --switch=%s" % (
                    flowvisors[i]["host"], flowvisors[i]["of_port"], switch,
                )
            client = SSHClientPlus.exec_command_plus(
                mininet_vms[i][0], "mininet", "mininet", cmd,
                port=mininet_vms[i][1],
            )
            self.mininet_vm_clients.append(client)
            logger.debug(
                client.wait_for_prompt(
                    prompt="Starting CLI:\n", timeout=test_settings.TIMEOUT))

    def run_flowvisor(self, flowvisor):
        """
        Run flowvisor.
        Delete all the rules and slices.
        """
        
        if RUN_FV_SUBPROCESS:
            kill_old_procs(flowvisor["of_port"],
                           flowvisor["xmlrpc_port"])

            self.fv_procs.append(
                self.run_proc_cmd(
                    "%s/scripts/flowvisor.sh %s/%s 2>&1 | tee /tmp/flowvisor.out " % (
                        flowvisor["path"][0], flowvisor["path"][0],
                        flowvisor["path"][1],
                    )
                )
            )
        
        id_re = re.compile(r"id=\[(?P<id>\d+)\]")
        fv_url = "https://%s:%s@%s:%s" % (
            flowvisor["username"], flowvisor["password"],
            flowvisor["host"], flowvisor["xmlrpc_port"],
        )

        s = xmlrpclib.ServerProxy(fv_url)
        
        logger.debug("Waiting for flowvisor to be up.")
        ret = wrap_xmlrpc_call(s.api.ping, ["PONG"], {}, test_settings.TIMEOUT)
        logger.debug("Ping returned: %s" % ret)
        
        logger.debug("Getting flowspace from flowvisor")
        flowspaces = s.api.listFlowSpace()
        ops = []
        logger.debug("Deleting all flowspace")
        for fs in flowspaces:
            id = id_re.search(fs).group("id")
            ops.append(dict(operation="REMOVE", id=id))
        if ops: s.api.changeFlowSpace(ops)
        
        slices = s.api.listSlices()
        [s.api.deleteSlice(slice) for slice in slices if slice != "root"]
        
        self.fv_clients.append(s)
        
    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 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 run_proc_cmd(self, cmd, wait=False):
        """
        Run a command in a subprocess, return the new process.
        """
        if test_settings.SHOW_PROCESSES_IN_XTERM:
            from expedient.common.tests.utils import run_cmd_in_xterm as run_cmd
        else:
            from expedient.common.tests.utils import run_cmd
            
        if wait:
            return run_cmd(cmd).wait()
        else:
            return run_cmd(cmd)
        
    def run_am_proxy(self, gcf_dir, ssl_dir, am_port, ch_host, ch_port):
        """
        Create the ssl certs for the tests.
        Run the AM proxy in a separate process.
        """

        # create the certs if not already there.
        self.run_proc_cmd("make -C %s" % ssl_dir).wait()
        
        # run the am
#        self.am_proc = self.run_proc_cmd(
#            "python %s -r %s -c %s -k %s -p %s -u %s --debug -H 0.0.0.0" % (
#                join(gcf_dir, "gam.py"), join(ssl_dir, "certs"),
#                join(ssl_dir, "server.crt"), join(ssl_dir, "server.key"),
#                am_port,
#                SCHEME + "://%s:%s/openflow/gapi/"
#                % (ch_host, ch_port),
#            )
#        )
        cert_transport = SafeTransportWithCert(
            keyfile=join(ssl_dir, "experimenter.key"),
            certfile=join(ssl_dir, "experimenter.crt"))
        self.am_client = xmlrpclib.ServerProxy(
            "https://%s:%s/openflow/gapi/" % (test_settings.HOST, am_port),
            transport=cert_transport)
        
    def run_geni_ch(self, gcf_dir, ssl_dir, ch_port):
        """
        Run the GENI Sample CH in a subprocess and connect to it.
        """
        self.ch_proc = self.run_proc_cmd(
            "python %s -u %s -r %s -c %s -k %s -p %s --debug -H 0.0.0.0" % (
                join(gcf_dir, "gch.py"),
                join(ssl_dir, "experimenter.crt"),
                join(ssl_dir, "certs"),
                join(ssl_dir, "ch.crt"), join(ssl_dir, "ch.key"),
                ch_port,
            )
        )
        cert_transport = SafeTransportWithCert(
            keyfile=join(ssl_dir, "experimenter.key"),
            certfile=join(ssl_dir, "experimenter.crt"))
        self.ch_client = xmlrpclib.ServerProxy(
            "https://%s:%s/" % (test_settings.HOST, ch_port),
            transport=cert_transport)

    def create_ch_slice(self):
        """
        Code mostly copied from GENI test harness from BBN.
        """
        import gcf.sfa.trust.credential as cred
        
        slice_cred_string = wrap_xmlrpc_call(
            self.ch_client.CreateSlice, [], {}, test_settings.TIMEOUT)
        slice_credential = cred.Credential(string=slice_cred_string)
        slice_gid = slice_credential.get_gid_object()
        slice_urn = slice_gid.get_urn()
        
        # Set up the array of credentials as just the slice credential
        credentials = [slice_cred_string]
        
        return (slice_urn, credentials)

    def setUp(self):
        """
        Run dummy networks and connect them to the FVs
        Run dummy Controllers
        Load the configuration for the OM
        Load the configuration for the AM
        """
        # Kill stale processes
        kill_old_procs(test_settings.GAM_PORT, test_settings.GCH_PORT)
        
        self.ch_username = "******"
        self.ch_passwd = "ch_password"

        # clear all slices/flowspaces from fvs
        self.fv_procs = []
        self.fv_clients = []
        for flowvisor in test_settings.FLOWVISORS:
            self.run_flowvisor(flowvisor)
        
#        # run experiment controllers
#        self.run_nox(
#            test_settings.MININET_VMS[0][0],
#            test_settings.NUM_EXPERIMENTS,
#            6633,
#        )
        
        # connect the networks to FVs
        self.connect_networks(
            test_settings.FLOWVISORS,
            test_settings.MININET_VMS,
            test_settings.MININET_SWITCH_TYPE,
        )
        
        # setup the OM
        self.prepare_om(
            test_settings.OM_PROJECT_DIR,
            test_settings.FLOWVISORS[0],
            self.ch_username,
            self.ch_passwd,
        )
        
        # setup Expedient (aka AM)
        self.prepare_ch(
            test_settings.CH_PROJECT_DIR,
            test_settings.HOST,
            test_settings.CH_PORT,
            self.ch_username,
            self.ch_passwd,
            test_settings.HOST,
            test_settings.OM_PORT,
        )

        # store the trusted CA dir
        import os
        from django.conf import settings as djangosettings
        self.before = os.listdir(djangosettings.XMLRPC_TRUSTED_CA_PATH)

        # Run the AM proxy for GENI and Expedient
        self.run_geni_ch(
            test_settings.GCF_DIR, test_settings.SSL_DIR, test_settings.GAM_PORT)
        self.run_am_proxy(
            test_settings.GCF_DIR, test_settings.SSL_DIR, test_settings.GCH_PORT,
            test_settings.HOST, test_settings.CH_PORT)
        
    def tearDown(self):
        """
        Clean up the Flowvisor rules/slices
        Clear running stuff and so on...
        """
        # restore the trusted CA dir
        from django.conf import settings as djangosettings
        import os
        after = os.listdir(djangosettings.XMLRPC_TRUSTED_CA_PATH)
        for path in after:
            if path not in self.before:
                os.unlink(os.path.join(djangosettings.XMLRPC_TRUSTED_CA_PATH, path))

        if test_settings.PAUSE_AFTER_TESTS:
            raw_input("Press ENTER to continue:")
            
        # clear all slices/flowspaces from fvs
        if RUN_FV_SUBPROCESS:
            for fv_proc in self.fv_procs:
                try:
                    fv_proc.terminate()
                except:
                    pass
        
        self.am_proc.terminate()
        self.ch_proc.terminate()
        
        # kill ssh sessions
#        for c in self.nox_clients:
#            out = c.communicate("\03", check_closed=True)
#            logger.debug("nox stdout %s" % out)
            
        for c in self.mininet_vm_clients:
            out = c.communicate("exit()\n", check_closed=True)
            logger.debug("mn stdout %s" % out)
            c.wait()
        
        if RUN_FV_SUBPROCESS:
            for flowvisor in test_settings.FLOWVISORS:
                kill_old_procs(flowvisor["of_port"], flowvisor["xmlrpc_port"])
        
        # Kill stale processes
        kill_old_procs(test_settings.GAM_PORT, test_settings.GCH_PORT)

#        for c in self.nox_clients:
#            try:
#                c.close()
#            except:
#                pass

        for c in self.fv_procs:
            try:
                c.close()
            except:
                pass

            
        for c in self.mininet_vm_clients:
            try:
                c.close()
            except:
                pass

    def create_sliver_core(self,fs_randomness):
        """
        Check that we can create slice on the FV
        """
        # check no other slices
        slices = self.fv_clients[0].api.listSlices()
        self.assertEqual(len(slices), 1) # root
        
        # get the resources
        slice_urn, cred = self.test_ListResources()
        
        # create a random reservation
        slice_name = "SliceNameBla"
        email = "*****@*****.**"
        url = "tcp:%s:%s" % (test_settings.MININET_VMS[0][0], 6633)
        resv_rspec, flowspaces = create_random_resv(
            2, self.switches,
            slice_name=slice_name,
            email=email,
            ctrl_url=url,
            fs_randomness = fs_randomness,
        )
        users = [{'key':''}]
        self.am_client.CreateSliver(slice_urn, cred, resv_rspec, users)
        
        # TODO: check that the full reservation rspec is returned
        slices = self.fv_clients[0].api.listSlices()
        logger.debug(slices)

        self.assertEqual(len(slices), 2) # root + new slice
        
        fv_slice_name = slices[1] if slices[0] == "root" else slices[0]
        
        # Check the name
        self.assertTrue(
            slice_name in fv_slice_name, 
            "Expected to find '%s' in slice name '%s', but didn't" % (
                slice_name, fv_slice_name,
            )
        )
        
        # Check the slice information
        slice_info = self.fv_clients[0].api.getSliceInfo(fv_slice_name)
        logger.debug("Slice info is %s" % slice_info)
        self.assertEqual(slice_info["contact_email"], email)
        self.assertEqual(slice_info["controller_port"], "6633")
        self.assertEqual(slice_info["controller_hostname"],
                         test_settings.MININET_VMS[0][0])
        
        return (slice_urn, cred)

    def test_GetVersion(self):
        ret = wrap_xmlrpc_call(
            self.am_client.GetVersion, [], {}, test_settings.TIMEOUT)
        self.assertEqual(ret['geni_api'], 1)
    

    def test_ListResources(self):
        """
        Check the list of resources.
        """

        # check the switches on the FV
        devices = self.fv_clients[0].api.listDevices()
        logger.debug("FV devices: %s" % devices)
        self.assertEqual(len(set(devices)), self.EXPECTED_NUM_SWITCHES)
        
        slice_urn, cred = self.create_ch_slice()
        options = dict(geni_compressed=False, geni_available=True)
        rspec = wrap_xmlrpc_call(
            self.am_client.ListResources, [cred, options], {}, 
            test_settings.TIMEOUT)
        
        logger.debug(rspec)
        
        # Create switches and links
        self.switches, self.links = parse_rspec(rspec)
        
        # check the number of switches and links
        self.assertEqual(len(self.switches), self.EXPECTED_NUM_SWITCHES)
        self.assertEqual(len(self.links), self.EXPECTED_NUM_LINKS)
        return slice_urn, cred
        
    def test_CreateSliver(self):
        """
        Check that we can create slice on the FV
        """
        return self.create_sliver_core(fs_randomness=True)
        

    def test_CreateDeleteSliver(self):
        """
        Check that we can create then delete a sliver.
        """
        slice_urn, cred = self.test_CreateSliver()
        
        self.assertTrue(
            wrap_xmlrpc_call(
                self.am_client.DeleteSliver,
                [slice_urn, cred], {}, 
                test_settings.TIMEOUT),
            "Failed to delete sliver.")
        
        self.assertEqual(
            len(self.fv_clients[0].api.listSlices()),
            1,
            "Slice not deleted at FlowVisor",
        )
        
    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 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)
Exemple #4
0
    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()
Exemple #5
0
from os.path import join, dirname
import time
import subprocess
import shlex
PYTHON_DIR = join(dirname(__file__), "../../../")
sys.path.append(PYTHON_DIR)

from unittest import TestCase
import xmlrpclib
from openflow.tests import test_settings as settings
from openflow.tests.helpers import parse_rspec, create_random_resv, \
    kill_old_procs
from expedient.common.utils.certtransport import SafeTransportWithCert
from expedient.common.tests.commands import call_env_command, Env

ch_env = Env(settings.CH_PROJECT_DIR)
ch_env.switch_to()

if settings.SHOW_PROCESSES_IN_XTERM:
    from expedient.common.tests.utils import run_cmd_in_xterm as run_cmd
else:
    from expedient.common.tests.utils import run_cmd
from expedient.common.tests.utils import wrap_xmlrpc_call, drop_to_shell
from expedient.common.tests.client import Browser

import logging
logger = logging.getLogger("openflow.tests.gapi")

SCHEME = "https" if settings.USE_HTTPS else "http"

Exemple #6
0
class OMTests(TestCase):
    
    def setUp(self):
        """
        Load up a DB for the OM.
        Create a client to talk to the OM.
        """
        
        
        call_env_command(test_settings.OM_PROJECT_DIR, "flush",
                         interactive=False)
        self.om_env = Env(test_settings.OM_PROJECT_DIR)
        self.om_env.switch_to()
        
        from openflow.optin_manager.dummyfv.models import DummyFV
        from openflow.optin_manager.xmlrpc_server.models import FVServerProxy
        from openflow.optin_manager.users.models import UserProfile
        from django.contrib.auth.models import User 

        # Create the Expedient user
        username = "******"
        password = "******"
        u = User.objects.create(username=username)
        u.set_password(password)
        u.save()
        
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_Expedient_user = True
        profile.save()
        self.om_client = xmlrpclib.ServerProxy(
            SCHEME + "://%s:%s@%s:%s/xmlrpc/xmlrpc/" % (
                username, password, test_settings.HOST, test_settings.OM_PORT
            )
        )
        
        #creat admin user: use this to look at DBs through admin interface
        username = "******"
        password = "******"
        u = User.objects.create(username=username, is_superuser=True,
                                is_staff=True, is_active=True)
        u.set_password(password)
        u.save()
        profile = UserProfile.get_or_create_profile(u) 
        profile.is_net_admin = True
        profile.supervisor = u
        profile.max_priority_level = 7000
        profile.save()      
         
         
        # Create dummy FVs
        for i in range(test_settings.NUM_DUMMY_FVS):
            fv = DummyFV.objects.create()
            # Load up a fake topology in the Dummy FV
            fv.populateTopology(10, 20, use_random=test_settings.USE_RANDOM)
            
            # create fake users for the Dummy FV
            username = "******" % i
            password = "******"
            u = User.objects.create(username=username)
            u.set_password(password)
            u.save()

            # Create the FV proxy connection
            FVServerProxy.objects.create(
                name="Flowvisor %s" % i,
                username=username,
                password=password,
                url = SCHEME+"://%s:%s/dummyfv/%s/xmlrpc/" % (
                    test_settings.HOST, test_settings.OM_PORT, fv.id,
                ),
            )
             
 
    def test_ping(self):
        """
        Communications are up.
        """
        ret = wrap_xmlrpc_call(
            self.om_client.ping, ["PING"], {}, test_settings.TIMEOUT)
        self.assertEqual(ret, "PONG: PING", "Ping returned %s." % ret)
        
    def test_get_switches(self):
        """
        Test that a slice can be created and the calls are routed to the
        FV correctly.
        """
        from openflow.optin_manager.dummyfv.models import DummyFVDevice

        # TODO: Fix to also check the returned info
        self.dpids_info = wrap_xmlrpc_call(
            self.om_client.get_switches, [], {}, test_settings.TIMEOUT)
        dpids = set([d[0] for d in self.dpids_info])
        
        # check that we expect all the dpids
        expected = set(
            DummyFVDevice.objects.values_list('dpid', flat=True),
        )
        
        self.assertEqual(
            dpids, expected, 
            "Received dpids (%s) not same as expected (%s)." % (
                dpids, expected,
            )
        )
        
    def test_get_links(self):
        """
        Tests that the links are retrieved correctly from the FV.
        """
        from openflow.optin_manager.dummyfv.models import DummyFVLink

        links = wrap_xmlrpc_call(
            self.om_client.get_links, [], {}, test_settings.TIMEOUT)
        links = set([tuple(l[:-1]) for l in links])
#        print "Received links:"
#        pprint(links)
        
        # TODO add checking for the link_infos (link attributes)
        
        expected = set([(
            link.src_dev.dpid,
            link.src_port,
            link.dst_dev.dpid,
            link.dst_port) for link in DummyFVLink.objects.all()])
#        print "Expected links:"
#        pprint(expected)
        
        self.assertTrue(
            links.issubset(expected),
            "Received links have %s not in expected links" % (
                links - expected,
            )
        )
        self.assertTrue(
            expected.issubset(links),
            "Expected links have %s not in received links" % (
                expected - links,
            )
        )
        
    def test_change_password(self):
        """
        Tests that the Expedient password can be changed correctly.
        """
        from django.contrib.auth.models import User
        wrap_xmlrpc_call(
            self.om_client.change_password, ["new_password"], {},
            test_settings.TIMEOUT)
        
        user = User.objects.get(username="******")
        
        self.assertTrue(user.check_password("new_password"))
        
    
    def test_topology_callback(self):
        # TODO: write up test_topology_callback
        pass
    
    def test_create_slice(self, id=10):
        """
        Tests that slices are created correctly from the OM to the FV
        """
        from openflow.tests.helpers import Flowspace
        from openflow.optin_manager.dummyfv.models import DummyFV, DummyFVRule
        from openflow.optin_manager.dummyfv.models import DummyFVSlice
        from openflow.optin_manager.opts.models import Experiment
        from openflow.optin_manager.opts.models import ExperimentFLowSpace
        from openflow.optin_manager.xmlrpc_server.ch_api import convert_star_int
        
        # get the switches into self.dpids_info
        self.test_get_switches()
        
        # create some random flowspaces
        switch_slivers=[]
        for i in xrange(10):
            switch = random.choice(self.dpids_info)
#            print "Creating flow space for switch %s" % switch
            fs_set = [Flowspace.create_random([switch]) \
                      for j in range(random.randint(1,10))]
            switch_slivers.append({
                "datapath_id": switch[0],
                "flowspace": [fs.get_full_attrs() for fs in fs_set],
            })
        
        args = {
            "slice_id": id,
            "project_name": "project_name",
            "project_description": "project_description",
            "slice_name": "slice name-%s" % id,
            "slice_description": "slice_description",
            "controller_url": "bla:bla.bla.bla:6633",
            "owner_email": "*****@*****.**",
            "owner_password": "******",
            "switch_slivers": switch_slivers,
        }
        
        # Create!
        ret = self.om_client.create_slice(
            args["slice_id"], args["project_name"], args["project_description"],
            args["slice_name"], args["slice_description"],
            args["controller_url"], args["owner_email"], args["owner_password"],
            args["switch_slivers"]
        )
        
        # check the return value
        self.assertEqual(ret, {'error_msg': "", 'switches': []})
        
        # check the OM database to see if Experiment has been created correctly

        returned = Experiment.objects.filter(slice_name=args["slice_name"])
        self.assertEqual(
            returned.count(), 1 ,
            "more than one slice with same name %s" % args["slice_name"])
        returned_string = "%s %s %s %s %s %s %s %s" % (
            returned[0].slice_id, returned[0].slice_name,
            returned[0].slice_desc, returned[0].project_name,
            returned[0].project_desc, returned[0].controller_url,
            returned[0].owner_email, returned[0].owner_password
        )
        expected_string = "%s %s %s %s %s %s %s %s" % ( 
            args["slice_id"],args["slice_name"],
            args["slice_description"],args["project_name"],
            args["project_description"],args["controller_url"],
            args["owner_email"],args["owner_password"])

        self.assertEqual(
            returned_string, expected_string,
            "The OM Experiment table is different " + \
            "from what expected %s != %s" % (returned_string,expected_string)
        )
        
        # check the OM database to see if ExperimentFlowSpace 
        # has been created correctly
        expfs = ExperimentFLowSpace.objects.filter(exp=returned[0])
        returned_string = ""
        for fs in expfs:
            returned_string = "%s %s %s %s %s " % (
                returned_string, fs.dpid, fs.port_number_s, fs.port_number_e,
                fs.stringify()
            )
        expected_string = ""

        for sliver in args["switch_slivers"]:
            for fs in sliver["flowspace"]:
                fs = convert_star_int(fs)
                expected_string = \
                    "%s %s %s %s %s %s %s %s %s %s %s " % (
                        expected_string, sliver["datapath_id"],
                        fs["port_num_start"], fs["port_num_end"],
                        fs["dl_src_start"], fs["dl_src_end"],
                        fs["dl_dst_start"], fs["dl_dst_end"],
                        fs["vlan_id_start"], fs["vlan_id_end"],
                        fs["nw_src_start"],
                    ) +\
                    "%s %s %s %s %s %s %s %s %s " % (
                        fs["nw_src_end"], fs["nw_dst_start"], fs["nw_dst_end"],
                        fs["nw_proto_start"], fs["nw_proto_end"],
                        fs["tp_src_start"], fs["tp_src_end"],
                        fs["tp_dst_start"], fs["tp_dst_end"]
                    )

        self.assertEqual(
            returned_string, expected_string,
            "Experiment FlowSpaces are not equal %s != %s" % (
                returned_string,expected_string
            )
        )

        for fv in DummyFV.objects.all():
#            DummyFVSlice.objects.get(
#                name="%s ID: %s" % (args["slice_name"], args["slice_id"]),
#                password=args["owner_password"],
#                controller_url=args["controller_url"],
#                email=args["owner_email"],
#                fv=fv,
#            )
            self.assertEqual(DummyFVRule.objects.filter(fv=fv).count(), 0)

    def test_delete_slice(self):
        """
        Tests that slices are deleted correctly from the OM to FV
        """
        from openflow.optin_manager.dummyfv.models import DummyFV, DummyFVSlice
        from openflow.optin_manager.opts.models import Experiment, \
            ExperimentFLowSpace

        num_slices = random.randint(1, 5)
        for i in range(num_slices):
            self.test_create_slice(id=i)
        
        # delete some slices and make sure they are gone
        ids = range(1, num_slices)
        random.shuffle(ids)
        for i in ids:
            err = wrap_xmlrpc_call(
                self.om_client.delete_slice, [i], {}, test_settings.TIMEOUT)
            self.assertEqual(err, "")
            num_slices -= 1
            for fv in DummyFV.objects.all():
                num_actual_slices = DummyFVSlice.objects.filter(fv=fv).count()
                self.assertTrue(
                    num_actual_slices == num_slices,
                    "Expected %s slices after delete but found %s" % (
                        num_slices, num_actual_slices))
            # Check internal OM database:
            count = Experiment.objects.all().count()
            self.assertEqual(
                count,num_slices,
                "There are more slices in OM than expected")
            count = Experiment.objects.filter(slice_id=i).count()
            self.assertEqual(count, 0, "Slice in OM has not deleted!")
            count = ExperimentFLowSpace.objects.filter(
                exp__slice_id = i).count() 
            self.assertEqual(
                count, 0,
                "FlowSpace associated with experiment slice_id" +\
                "=%d has not deleted completely" % i)            
    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()  
from os.path import join, dirname
import time
import subprocess
import shlex
PYTHON_DIR = join(dirname(__file__), "../../../")
sys.path.append(PYTHON_DIR)

from unittest import TestCase
import xmlrpclib
from openflow.tests import test_settings as settings
from openflow.tests.helpers import parse_rspec, create_random_resv, \
    kill_old_procs
from expedient.common.utils.certtransport import SafeTransportWithCert
from expedient.common.tests.commands import call_env_command, Env

ch_env = Env(settings.CH_PROJECT_DIR)
ch_env.switch_to()

if settings.SHOW_PROCESSES_IN_XTERM:
    from expedient.common.tests.utils import run_cmd_in_xterm as run_cmd
else:
    from expedient.common.tests.utils import run_cmd
from expedient.common.tests.utils import wrap_xmlrpc_call, drop_to_shell
from expedient.common.tests.client import Browser

import logging
logger = logging.getLogger("openflow.tests.gapi")

SCHEME = "https" if settings.USE_HTTPS else "http"

def get_base_url(path):