Python WebLabDeustoClient.get_experiment_use_by_id方法代码示例

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import get_experiment_use_by_id [as 别名]
    def test_get_experiment_use_by_id(self):
        port = 15129
        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")
            expected_reservation_id = SessionId.SessionId("foobar")
            expected_alive_result = RunningReservationResult()

            self.mock_server.return_values['get_experiment_use_by_id'] = expected_alive_result


            obtained_result = client.get_experiment_use_by_id(expected_sess_id, expected_reservation_id)
            self.assertEquals(RunningReservationResult(), obtained_result)
        finally:
            self.rfs.stop()

# 需要导入模块: from weblab.core.coordinator.clients.weblabdeusto import WebLabDeustoClient [as 别名]
# 或者: from weblab.core.coordinator.clients.weblabdeusto.WebLabDeustoClient import get_experiment_use_by_id [as 别名]
class AbstractFederatedWebLabDeustoTestCase(object):
    def setUp(self):
        # Clean the global registry of servers
        GLOBAL_REGISTRY.clear()

        CONSUMER_CONFIG_PATH  = self.FEDERATED_DEPLOYMENTS + '/consumer/'
        PROVIDER1_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider1/'
        PROVIDER2_CONFIG_PATH = self.FEDERATED_DEPLOYMENTS + '/provider2/'

        self.consumer_handler  = load_dir(CONSUMER_CONFIG_PATH).load_process('consumer_machine', 'main_instance' )
        self.provider1_handler = load_dir(PROVIDER1_CONFIG_PATH).load_process('provider1_machine', 'main_instance' )
        self.provider2_handler = load_dir(PROVIDER2_CONFIG_PATH).load_process('provider2_machine', 'main_instance' )
        
        self.consumer_client  = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 18345)

        self.provider1_client  = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 28345)

        self.provider2_client  = WebLabDeustoClient("http://127.0.0.1:%s/weblab/" % 38345)

        # dummy1: deployed in consumer, provider1, provider2
        self.dummy1 = ExperimentId("dummy1", "Dummy experiments")
        # dummy2: deployed in consumer
        self.dummy2 = ExperimentId("dummy2", "Dummy experiments")
        # dummy3: deployed in provider1 as "dummy3_with_other_name"
        self.dummy3 = ExperimentId("dummy3", "Dummy experiments")
        # dummy4: deployed in provider2
        self.dummy4 = ExperimentId("dummy4", "Dummy experiments")

    def tearDown(self):
        self.consumer_handler.stop()
        self.provider1_handler.stop()
        self.provider2_handler.stop()
        time.sleep(1)

    #
    # This test may take even 20-30 seconds; therefore it is not splitted
    # into subtests (the setup and teardown are long)
    #
    def test_federated_experiment(self):
        debug("Test test_federated_experiment starts")

        #######################################################
        #
        #   Local testing  (to check that everything is right)
        #
        #   We enter as a student of Consumer, and we ask for an
        #   experiment that only the Consumer university has
        #   (dummy2).
        #
        session_id = self.consumer_client.login('fedstudent1', 'password')

        reservation_id = self._test_reservation(session_id, self.dummy2, 'Consumer', 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, 'Consumer')


        #######################################################
        #
        #   Simple federation
        #
        #   Now we ask for an experiment that only Provider 1
        #   has. There is no load balance, neither
        #   subcontracting
        #
        reservation_id = self._test_reservation(session_id, self.dummy3, 'Provider 1', 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 1')

        #######################################################
        #
        #   Subcontracted federation
        #
        #   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)
#.........这里部分代码省略.........