Beispiel #1
0
    def _get_execution_info(self, input_dict):
        tests = input_dict.get('tests', '')
        client_control_file = input_dict.get('client_control_file', None)
        if not tests and not client_control_file:
            return self._DEFAULTS

        test_list = tests.split(',')
        if 'profilers' in input_dict:
            profilers_list = input_dict['profilers'].split(',')
        else:
            profilers_list = []
        kernels = input_dict.get('kernels', '')  # TODO
        if kernels:
            kernels = [dict(version=kernel) for kernel in kernels.split(',')]

        cf_info, test_objects, profiler_objects, label = (
            rpc_utils.prepare_generate_control_file(test_list, kernels, None,
                                                    profilers_list))
        control_file_contents = control_file.generate_control(
            tests=test_objects,
            kernels=kernels,
            profilers=profiler_objects,
            is_server=cf_info['is_server'],
            client_control_file=client_control_file,
            profile_only=input_dict.get('profile_only', None),
            upload_kernel_config=input_dict.get('upload_kernel_config', None))
        return dict(self._DEFAULTS,
                    control_file=control_file_contents,
                    is_server=cf_info['is_server'],
                    dependencies=cf_info['dependencies'],
                    machines_per_execution=cf_info['synch_count'])
Beispiel #2
0
    def _get_execution_info(self, input_dict):
        tests = input_dict.get('tests', '')
        client_control_file = input_dict.get('client_control_file', None)
        if not tests and not client_control_file:
            return self._DEFAULTS

        test_list = tests.split(',')
        if 'profilers' in input_dict:
            profilers_list = input_dict['profilers'].split(',')
        else:
            profilers_list = []
        kernels = input_dict.get('kernels', '') # TODO
        if kernels:
            kernels = [dict(version=kernel) for kernel in kernels.split(',')]

        cf_info, test_objects, profiler_objects, label = (
                rpc_utils.prepare_generate_control_file(
                        test_list, kernels, None, profilers_list))
        control_file_contents = control_file.generate_control(
                tests=test_objects, kernels=kernels,
                profilers=profiler_objects, is_server=cf_info['is_server'],
                client_control_file=client_control_file,
                profile_only=input_dict.get('profile_only', None),
                upload_kernel_config=input_dict.get(
                    'upload_kernel_config', None))
        return dict(self._DEFAULTS,
                    control_file=control_file_contents,
                    is_server=cf_info['is_server'],
                    dependencies=cf_info['dependencies'],
                    machines_per_execution=cf_info['synch_count'])
Beispiel #3
0
def generate_control_file(
    tests=(),
    kernel=None,
    label=None,
    profilers=(),
    client_control_file="",
    use_container=False,
    profile_only=None,
    upload_kernel_config=False,
):
    """
    Generates a client-side control file to load a kernel and run tests.

    :param tests List of tests to run.
    :param kernel A list of kernel info dictionaries configuring which kernels
        to boot for this job and other options for them
    :param label Name of label to grab kernel config from.
    :param profilers List of profilers to activate during the job.
    :param client_control_file The contents of a client-side control file to
        run at the end of all tests.  If this is supplied, all tests must be
        client side.
        TODO: in the future we should support server control files directly
        to wrap with a kernel.  That'll require changing the parameter
        name and adding a boolean to indicate if it is a client or server
        control file.
    :param use_container unused argument today.  TODO: Enable containers
        on the host during a client side test.
    :param profile_only A boolean that indicates what default profile_only
        mode to use in the control file. Passing None will generate a
        control file that does not explcitly set the default mode at all.
    :param upload_kernel_config: if enabled it will generate server control
            file code that uploads the kernel config file to the client and
            tells the client of the new (local) path when compiling the kernel;
            the tests must be server side tests

    :return: a dict with the following keys:
        control_file: str, The control file text.
        is_server: bool, is the control file a server-side control file?
        synch_count: How many machines the job uses per autoserv execution.
            synch_count == 1 means the job is asynchronous.
        dependencies: A list of the names of labels on which the job depends.
    """
    if not tests and not client_control_file:
        return dict(control_file="", is_server=False, synch_count=1, dependencies=[])

    cf_info, test_objects, profiler_objects, label = rpc_utils.prepare_generate_control_file(
        tests, kernel, label, profilers
    )
    cf_info["control_file"] = control_file.generate_control(
        tests=test_objects,
        kernels=kernel,
        platform=label,
        profilers=profiler_objects,
        is_server=cf_info["is_server"],
        client_control_file=client_control_file,
        profile_only=profile_only,
        upload_kernel_config=upload_kernel_config,
    )
    return cf_info
Beispiel #4
0
def generate_control_file(tests=(),
                          kernel=None,
                          label=None,
                          profilers=(),
                          client_control_file='',
                          use_container=False,
                          profile_only=None,
                          upload_kernel_config=False):
    """
    Generates a client-side control file to load a kernel and run tests.

    :param tests List of tests to run.
    :param kernel A list of kernel info dictionaries configuring which kernels
        to boot for this job and other options for them
    :param label Name of label to grab kernel config from.
    :param profilers List of profilers to activate during the job.
    :param client_control_file The contents of a client-side control file to
        run at the end of all tests.  If this is supplied, all tests must be
        client side.
        TODO: in the future we should support server control files directly
        to wrap with a kernel.  That'll require changing the parameter
        name and adding a boolean to indicate if it is a client or server
        control file.
    :param use_container unused argument today.  TODO: Enable containers
        on the host during a client side test.
    :param profile_only A boolean that indicates what default profile_only
        mode to use in the control file. Passing None will generate a
        control file that does not explcitly set the default mode at all.
    :param upload_kernel_config: if enabled it will generate server control
            file code that uploads the kernel config file to the client and
            tells the client of the new (local) path when compiling the kernel;
            the tests must be server side tests

    :return: a dict with the following keys:
        control_file: str, The control file text.
        is_server: bool, is the control file a server-side control file?
        synch_count: How many machines the job uses per autoserv execution.
            synch_count == 1 means the job is asynchronous.
        dependencies: A list of the names of labels on which the job depends.
    """
    if not tests and not client_control_file:
        return dict(control_file='',
                    is_server=False,
                    synch_count=1,
                    dependencies=[])

    cf_info, test_objects, profiler_objects, label = (
        rpc_utils.prepare_generate_control_file(tests, kernel, label,
                                                profilers))
    cf_info['control_file'] = control_file.generate_control(
        tests=test_objects,
        kernels=kernel,
        platform=label,
        profilers=profiler_objects,
        is_server=cf_info['is_server'],
        client_control_file=client_control_file,
        profile_only=profile_only,
        upload_kernel_config=upload_kernel_config)
    return cf_info