@typecheck(CoordAddress, ExperimentId, basestring, basestring, SessionId, (basestring, type(None)), datetime.datetime, datetime.datetime, basestring, dict)
    @logged()
    def confirm_experiment(self, experiment_coordaddress, experiment_id, reservation_id, lab_coordaddress_str, lab_session_id, server_initialization_response, initial_time, end_time, resource_type_name, exp_info):

        # 
        # Options parsing
        # 
        default_still_initialing      = False
        default_batch                 = False
        default_initial_configuration = "{}"
        if server_initialization_response is None or server_initialization_response == 'ok' or server_initialization_response == '':
            still_initializing = default_still_initialing
            batch = default_batch
            initial_configuration = default_initial_configuration
        else:
            try:
                response = json.loads(server_initialization_response)
                still_initializing    = response.get('keep_initializing', default_still_initialing)
                batch                 = response.get('batch', default_batch)
                initial_configuration = response.get('initial_configuration', default_initial_configuration)
            except Exception as e:
                log.log( AbstractCoordinator, log.level.Error, "Could not parse experiment server response: %s; %s; using default values" % (e, server_initialization_response) )
                log.log_exc( AbstractCoordinator, log.level.Warning )
                still_initializing    = default_still_initialing
                batch                 = default_batch
                initial_configuration = default_initial_configuration

        # 
        # 
        # Ensuring that no other reservation has been confirmed in the meanwhile
        # 
        # 
        aggregator = self._get_scheduler_aggregator_per_reservation(reservation_id)
        removed    = aggregator.assign_single_scheduler(reservation_id, resource_type_name, True)
        if removed is None:
            return

        
        #
        # Proceeding with this reservation
        # 
        serialized_request_info, serialized_client_initial_data = self.reservations_manager.get_request_info_and_client_initial_data(reservation_id)
        request_info  = json.loads(serialized_request_info)

        # Put the entry into a queue that is continuosly storing information into the db
        initial_information_entry = TemporalInformationStore.InitialInformationEntry(
            reservation_id, experiment_id, experiment_coordaddress,
            initial_configuration, initial_time, end_time, request_info,
            serialized_client_initial_data )

        self.initial_store.put(initial_information_entry)

        now = self.time_provider.get_datetime()
        self.post_reservation_data_manager.create(reservation_id, now, now + self.expiration_delta, json.dumps(initial_configuration))

        if still_initializing:
            # TODO XXX
            raise NotImplementedError("Not yet implemented: still_initializing")

        aggregator = self._get_scheduler_aggregator_per_reservation(reservation_id)
        aggregator.confirm_experiment(reservation_id, lab_session_id, initial_configuration, exp_info)

        if batch: # It has already finished, so make this experiment available to others
            self.finish_reservation(reservation_id)
            return

        self.confirmer.enqueue_should_finish(lab_coordaddress_str, lab_session_id, reservation_id)

    ################################################################
    #
    # Called when the Laboratory Server states that the experiment
    # was cleaned
    #
dataset/ETHPy150Open weblabdeusto/weblabdeusto/server/src/weblab/core/coordinator/coordinator.py/AbstractCoordinator.confirm_experiment/original