Python WebLabDeustoClient.finished_experiment方法代码示例

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]
    def test_finished_experiment(self):
        port = 15127
        self.configurationManager._set_value(self.rfs.FACADE_JSON_PORT, port)
        self.rfs.start()
        try:
            client = WebLabDeustoClient("http://localhost:%s/weblab/" % port)

            expected_sess_id = SessionId.SessionId("whatever")

            self.mock_server.return_values['finished_experiment'] = None

            client.finished_experiment(expected_sess_id)

            self.assertEquals(
                    expected_sess_id.id,
                    self.mock_server.arguments['finished_experiment'][0]
                )
        finally:
            self.rfs.stop()

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]

#.........这里部分代码省略.........
        #   Now we ask for an experiment that only Provider 2
        #   has. There is no load balance, but Consumer will
        #   contact Provider 1, which will contact Provider 2
        #
        reservation_id = self._test_reservation(session_id, self.dummy4, 'Provider 2', True, True)
        self._wait_multiple_reservations(20, session_id, [ reservation_id ], [0])
        reservation_result = self.consumer_client.get_experiment_use_by_id(session_id, reservation_id)
        self.assertTrue(reservation_result.is_finished())
        self._find_command(reservation_result, 'Provider 2')

        #######################################################
        #
        #   Cross-domain load balancing
        #
        #   Now we ask for an experiment that Consumer has,
        #   but also Provider 1 and Provider 2.
        #

        reservation_id1 = self._test_reservation(session_id, self.dummy1, 'Consumer',  True, False,  user_agent = 'Chrome')
        reservation_id2 = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False, user_agent = 'Firefox')
        reservation_id3 = self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False, user_agent = 'Safari')

        reservation_ids = (reservation_id1, reservation_id2, reservation_id3)
        reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids)

        self.assertEquals(RunningReservationResult(), reservation_results[0])
        self.assertEquals(RunningReservationResult(), reservation_results[1])
        self.assertEquals(RunningReservationResult(), reservation_results[2])


        #
        # What if one of them goes out and another comes? Is the load of experiments balanced correctly?
        #
        self.consumer_client.finished_experiment(reservation_id2)

        # Wait a couple of seconds to check that it has been propagated
        self._wait_multiple_reservations(20, session_id, reservation_ids, [1])

        reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids)

        # The other two are still running
        self.assertEquals(RunningReservationResult(), reservation_results[0])
        self.assertEquals(RunningReservationResult(), reservation_results[2])
        
        # But the one finished is actually finished
        self.assertTrue( reservation_results[1].is_finished() ) 
        self.assertEquals('Firefox', reservation_results[1].experiment_use.request_info['user_agent'])
        self.assertEquals(4, len(reservation_results[1].experiment_use.commands))
        self.assertEquals('Provider 1', reservation_results[1].experiment_use.commands[2].response.commandstring)

        reservation_id2b = self._test_reservation(session_id, self.dummy1, 'Provider 1', True, False)

        self.consumer_client.finished_experiment(reservation_id1)
        self._test_reservation(session_id, self.dummy1, 'Consumer', True, False)
        reservation_status = self.consumer_client.get_reservation_status(reservation_id3)
        provider2_reservation_id = reservation_status.remote_reservation_id

        self.consumer_client.finished_experiment(reservation_id3)
        self._test_reservation(session_id, self.dummy1, 'Provider 2', True, False)

        # Check for the other uses
        self._wait_multiple_reservations(70, session_id, reservation_ids, [0,2])

        reservation_results = self.consumer_client.get_experiment_uses_by_id(session_id, reservation_ids)
        self.assertTrue( reservation_results[0].is_finished() )
        self.assertEquals('Chrome', reservation_results[0].experiment_use.request_info['user_agent'])

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]
    def run(self):
        assertions  = []
        times       = []
        print "Starting process"

        reservation_id = None

        try:
            weblab      = WebLabDeustoClient(self.url)
            session_id  = weblab.login(self.username, self.password)
            reservation = weblab.reserve_experiment(session_id, ExperimentId("visir", "Visir experiments"), "{}", "{}")

            while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING):
                time.sleep(1)
                reservation = weblab.get_reservation_status( reservation.reservation_id )

            if reservation.status != Reservation.CONFIRMED:
                raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status))

            print "Confirmed reservation, starting..."

            reservation_id = reservation.reservation_id

            response = weblab.send_command(reservation_id, Command("GIVE_ME_SETUP_DATA"))
            cookie   = json.loads(response.commandstring)['cookie']

            login_response = weblab.send_command(reservation_id, Command(visir_commands.visir_login_request % cookie))

            visir_sessionid = visir_commands.parse_login_response(login_response)

            for _ in xrange(self.executions):
                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_11k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                assertions.append(AssertionResult(11000.0, 200, result))
                times.append(after - before)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_rectifier % visir_sessionid))
                after = time.time()
                # Don't know how to measure the response, but at least check that the response is a valid VISIR response
                result = visir_commands.parse_command_response(response, 'dmm_resolution')
                assertions.append(AssertionResult(3.5, 200, result))
                times.append(after - before)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_900 % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                assertions.append(AssertionResult(900.0, 200, result))
                times.append(after - before)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_1k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                assertions.append(AssertionResult(1000.0, 200, result))
                times.append(after - before)


                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_10k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                assertions.append(AssertionResult(10000.0, 200, result))
                times.append(after - before)

            weblab.finished_experiment(reservation_id)
        except Exception as exception:
            if reservation_id is not None:
                try:
                    weblab.finished_experiment(reservation_id)
                    loggedout = True
                except:
                    loggedout = False
            else:
                loggedout = "no id provided"
            print "Finished with exception and logged out: %s" % loggedout
            traceback.print_exc()

            return TesterResult(True, assertions, exception, times)
        else:
            print "Finished without exception"
            return TesterResult(any(map(lambda assertion : assertion.failed, assertions)), assertions, None, times)

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]

#.........这里部分代码省略.........

        experiments2 = self.client.list_experiments(session_id2)
        dummy_experiments2 = [ exp.experiment for exp in experiments2 if exp.experiment.name == 'dummy1' ]
        self.assertEquals( len(dummy_experiments2), 1 )

        experiments3 = self.client.list_experiments(session_id3)
        dummy_experiments3 = [ exp.experiment for exp in experiments3 if exp.experiment.name == 'dummy1' ]
        self.assertEquals( len(dummy_experiments3), 1 )

        experiments4 = self.client.list_experiments(session_id4)
        dummy_experiments4 = [ exp.experiment for exp in experiments4 if exp.experiment.name == 'dummy1' ]
        self.assertEquals( len(dummy_experiments4), 1 )

        experiments5 = self.client.list_experiments(session_id5)
        dummy_experiments5 = [ exp.experiment for exp in experiments5 if exp.experiment.name == 'dummy1' ]
        self.assertEquals( len(dummy_experiments5), 1 )

        experiments6 = self.client.list_experiments(session_id6)
        dummy_experiments6 = [ exp.experiment for exp in experiments6 if exp.experiment.name == 'dummy1' ]
        self.assertEquals( len(dummy_experiments6), 1 )

        # 3 users try to reserve the experiment
        status1 = self.client.reserve_experiment(session_id1, dummy_experiments1[0].to_experiment_id(), "{}", "{}")
        reservation_id1 = status1.reservation_id

        status2 = self.client.reserve_experiment(session_id2, dummy_experiments2[0].to_experiment_id(), "{}", "{}")
        reservation_id2 = status2.reservation_id

        status3 = self.client.reserve_experiment(session_id3, dummy_experiments3[0].to_experiment_id(), "{}", "{}")
        reservation_id3 = status3.reservation_id

        # wait until it is reserved
        short_time = 0.1
        times      = 10.0 / short_time

        while times > 0:
            time.sleep(short_time)
            new_status = self.client.get_reservation_status(reservation_id1)
            if not isinstance(new_status, Reservation.WaitingConfirmationReservation):
                break
            times -= 1

        # first user got the device. The other two are in WaitingReservation
        reservation1 = self.client.get_reservation_status(reservation_id1)
        self.assertTrue(isinstance(reservation1, Reservation.ConfirmedReservation))

        reservation2 = self.client.get_reservation_status(reservation_id2)
        self.assertTrue(isinstance(reservation2, Reservation.WaitingReservation))
        self.assertEquals( 0, reservation2.position)

        reservation3 = self.client.get_reservation_status(reservation_id3)
        self.assertTrue(isinstance(reservation3, Reservation.WaitingReservation))
        self.assertEquals( 1, reservation3.position)

        # Another user tries to reserve the experiment. He goes to the WaitingReservation, position 2
        status4 = self.client.reserve_experiment(session_id4, dummy_experiments4[0].to_experiment_id(), "{}", "{}")

        reservation_id4 = status4.reservation_id

        reservation4 = self.client.get_reservation_status(reservation_id4)
        self.assertTrue(isinstance( reservation4, Reservation.WaitingReservation))
        self.assertEquals( 2, reservation4.position)

        # The state of other users does not change
        reservation1 = self.client.get_reservation_status(reservation_id1)
        self.assertTrue(isinstance( reservation1, Reservation.ConfirmedReservation))

        reservation2 = self.client.get_reservation_status(reservation_id2)
        self.assertTrue(isinstance( reservation2, Reservation.WaitingReservation))
        self.assertEquals( 0, reservation2.position)

        reservation3 = self.client.get_reservation_status(reservation_id3)
        self.assertTrue(isinstance(reservation3, Reservation.WaitingReservation))
        self.assertEquals( 1, reservation3.position )

        # The user number 2 frees the experiment
        self.client.finished_experiment(reservation_id2)

        # Whenever he tries to do poll or send_command, he receives an exception
        try:
            time.sleep(1)
            self.client.poll(reservation_id2)
            self.client.poll(reservation_id2)
            self.client.poll(reservation_id2)
        except Exception as e:
            pass # All right :-)
            self.assertTrue("does not have any experiment" in repr(e))
        else:
            self.fail("Expected exception when polling")

        # send a program
        CONTENT = "content of the program DUMMY1"
        self.client.send_file(reservation_id1, ExperimentUtil.serialize(CONTENT), 'program')


        # We need to wait for the programming to finish.
        response = self.client.send_command(reservation_id1, Command.Command("STATE"))
        self.assertEquals("STATE", response.commandstring)

        self.client.logout(session_id1)

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]
    while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING):
        time.sleep(1)
        reservation = weblab.get_reservation_status( reservation.reservation_id )
        print ".",
        sys.stdout.flush()

    if reservation.status != Reservation.CONFIRMED:
        raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status))

    print "[done]"
    sys.stdout.flush()

    print "Confirmed reservation, programming file..."
    sys.stdout.flush()

    reservation_id = reservation.reservation_id

    # 
    # This code here is Robot dependent. Replace it with your code to check it.
    # 
    response = weblab.send_command(reservation_id, Command("program:Interactive Demo"))

    if response == 'File sended & running':
        print "File programmed. Exiting."
        sys.stdout.flush()

    weblab.finished_experiment(reservation_id)

print "Finished testing %s times" % N

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import finished_experiment [as 别名]
    def run(self):
        assertions  = []
        times       = []
        print "Starting process"

        reservation_id = None

        try:
            weblab      = WebLabDeustoClient(self.url)
            session_id  = weblab.login(self.username, self.password)
            reservation = weblab.reserve_experiment(session_id, ExperimentId(VISIR_EXPERIMENT, "Visir experiments"), "{}", "{}")

            while reservation.status in (Reservation.WAITING_CONFIRMATION or Reservation.WAITING):
                time.sleep(1)
                reservation = weblab.get_reservation_status( reservation.reservation_id )

            if reservation.status != Reservation.CONFIRMED:
                raise Exception("Confirmed reservation expected for reservation_id (%r). Found status: %r" % (reservation.reservation_id, reservation.status))

            print "Confirmed reservation, starting..."

            reservation_id = reservation.reservation_id
            initial_config = reservation.initial_configuration

            cookie   = json.loads(initial_config)['cookie']

            login_response = weblab.send_command(reservation_id, Command(visir_commands.visir_login_request % cookie))

            visir_sessionid = visir_commands.parse_login_response(login_response)

            iteration = 0
            
            for _ in xrange(self.executions):
                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_11k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                ar1 = AssertionResult(11000.0, 11000.0 * 0.2, result)
                if DEBUG and ar1.failed:
                    print "[Failed at 1st]" + str(ar1)
                if not IGNORE_ASSERTIONS: 
                    assertions.append(ar1)
                times.append(after - before)

# This command is currently commented out because it does not seem to be compatible with lxi_visir.
#                before = time.time()
#                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_rectifier % visir_sessionid))
#                after = time.time()
#                # Don't know how to measure the response, but at least check that the response is a valid VISIR response
#                result = visir_commands.parse_command_response(response, 'dmm_resolution')
#                assertions.append(AssertionResult(3.5, 200, result))
#                times.append(after - before)

                time.sleep(1)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_900 % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                ar3 = AssertionResult(900.0, 900.0 * 0.2, result)
                if DEBUG and ar3.failed:
                    print "[Failed at 3rd]" + str(ar3)
                if not IGNORE_ASSERTIONS:
                    assertions.append(ar3)
                times.append(after - before)

                time.sleep(1)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_1k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                ar4 = AssertionResult(1000.0, 1000 * 0.2, result)
                if DEBUG and ar4.failed:
                    print "[Failed at 4th]" + str(ar4)
                if not IGNORE_ASSERTIONS:
                    assertions.append(ar4)
                times.append(after - before)

                time.sleep(1)

                before = time.time()
                response = weblab.send_command(reservation_id, Command(visir_commands.visir_request_10k % visir_sessionid))
                after = time.time()
                result = visir_commands.parse_command_response(response)
                ar5 = AssertionResult(10000.0, 10000 * 0.2, result)
                if DEBUG and ar5.failed:
                    print "[Failed at 5th]" + str(ar5)
                if not IGNORE_ASSERTIONS:
                    assertions.append(ar5)
                times.append(after - before)
                
                iteration += 1
                
                time.sleep(1)

            weblab.finished_experiment(reservation_id)
        except Exception as exception:
            if reservation_id is not None:
                try:
#.........这里部分代码省略.........