def check_options(config):
    """Process options to manipulate (produce other options) important for pytest-cloud."""
    if getattr(config, 'slaveinput', {}).get('slaveid', 'local') == 'local' and config.option.cloud_nodes:
        patches.apply_patches()
        mem_per_process = config.option.cloud_mem_per_process
        if mem_per_process:
            mem_per_process = mem_per_process * 1024 * 1024
        virtualenv_path = config.option.cloud_virtualenv_path
        chdir = config.option.cloud_chdir
        python = config.option.cloud_python
        node_specs = get_nodes_specs(
            config.option.cloud_nodes,
            chdir=chdir,
            python=python,
            virtualenv_path=virtualenv_path,
            rsync_max_processes=config.option.cloud_rsync_max_processes,
            rsync_bandwidth_limit=config.option.cloud_rsync_bandwidth_limit,
            max_processes=config.option.cloud_max_processes,
            mem_per_process=mem_per_process,
            config=config)
        if node_specs:
            print('Scheduling with {0} parallel test sessions'.format(len(node_specs)))
        if not node_specs:
            pytest.exit('None of the given test nodes are able to serve as a test node due to capabilities')
        config.option.tx += node_specs
        config.option.dist = 'load'

def execute_before_any_test():
    print "Initializing tests"
    platform = pytest.config.getoption("--platform")
    if not platform:
        message = ["\n",
                   "Error running tests. Please specify a platform with a --platform flag, for example py.test tests --platform=browser",
                   "List of available platforms:",
                   "browser: run tests in the browser (with Peerio.AutomationSocket === true)",
                   "ios: run tests in the simulator",
                   "android: run tests in the GenyMotion simulator (please launch it before start)",
                   ""]
        pytest.exit('\n'.join(message))
        return

    method = getattr(common.helper, 'platform_' + platform)
    if not method:
        pytest.exit('platform not found: ' + platform)
        return

    platform_options = method()
    set_platform(platform_options)

    if 'appium' in platform_options and platform_options['appium']:
        restartAppium()

    if 'browserautomation' in platform_options and platform_options['browserautomation']:
        restartBrowserAutomation()

    if 'chromeriver' in platform_options and platform_options['chromedriver']:
        restartChromedriver()

    def stop(self):
        """Stop ManagedSubprocess instance and perform a cleanup

        This method makes sure that there are no child processes left after
        the object destruction finalizes. In case when a process cannot stop
        on it's own, it's forced to using SIGTERM/SIGKILL.
        """
        self._process.poll()
        if self._process.returncode is not None:
            msg_fmt = "`%s` process has already terminated with code `%s`"
            pytest.exit(msg_fmt % (self.id, self._process.returncode))
            return

        log.info("Send SIGINT to `%s` session leader", self.id)
        self._process.send_signal(signal.SIGINT)
        try:
            self._process.wait(self._EXIT_TIMEOUT / 2.0)
        except subprocess.TimeoutExpired:
            log.info("Send SIGTERM to `%s` session leader", self.id)
            self._process.send_signal(signal.SIGTERM)
            try:
                self._process.wait(self._EXIT_TIMEOUT / 2.0)
            except subprocess.TimeoutExpired:
                log.info("Send SIGKILL to all `%s` processess", self.id)
                os.killpg(os.getpgid(self._process.pid), signal.SIGKILL)
                log.info("wait() for `%s` session leader to die", self.id)
                self._process.wait()

        log.info("`%s` session leader has terminated", self.id)

def pytest_sessionstart(session):
    from .core import LibJulia, JuliaInfo, Julia, enable_debug

    options = JuliaOptions()
    for desc in JuliaOptions.supported_options():
        cli_option = "--julia-{}".format(desc.cli_argument_name().lstrip("-"))
        desc.__set__(options, session.config.getoption(cli_option))

    julia_runtime = session.config.getoption("julia_runtime")

    global _USING_DEFAULT_SETUP
    _USING_DEFAULT_SETUP = not (julia_runtime != "julia" or options.as_args())

    if not session.config.getoption("julia"):
        return

    enable_debug()
    global _JULIA_INFO
    _JULIA_INFO = info = JuliaInfo.load(julia=julia_runtime)

    if not info.is_pycall_built():
        print(
            """
PyCall is not installed or built.  Run the following code in Python REPL:

    >>> import julia
    >>> julia.install()

See:
    https://pyjulia.readthedocs.io/en/latest/installation.html
            """,
            file=sys.stderr,
        )
        pytest.exit("PyCall not built", returncode=1)

    if (
        options.compiled_modules != "no"
        and not info.is_compatible_python()
        and info.version_info >= (0, 7)
    ):
        print(
            """
PyJulia does not fully support this combination of Julia and Python.
Try:

    * Pass `--julia-compiled-modules=no` option to disable
      precompilation cache.

    * Use `--julia-runtime` option to specify different Julia
      executable.

    * Pass `--no-julia` to run tests that do not rely on Julia
      runtime.
            """,
            file=sys.stderr,
        )
        pytest.exit("incompatible runtimes", returncode=1)

    api = LibJulia.from_juliainfo(info)
    api.init_julia(options)

    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.docker = docker.from_env()
        if len(self.docker.images(name=self.image_name)) == 0:
            self._fetch_image()

        host_config = self.docker.create_host_config(
            binds=self.volumes_bindings,
            port_bindings=self.port_bindings
        )

        try:
            # following avoids conflict between different builds
            container_name_prefixed = '{}_{}'.format(os.path.basename(os.path.realpath('{}/../..'.format(__file__))),
                                                     self.container_name)
            self.container_id = self.docker.create_container(self.image_name, name=container_name_prefixed,
                                                             ports=self.ports, command=self.command,
                                                             environment=self.env_vars,
                                                             volumes=self.volumes, host_config=host_config).get('Id')
            self.logger.info("docker id is {}".format(self.container_id))
            self.logger.info("starting the temporary docker for image {}".format(self.image_name))
            self.docker.start(self.container_id)
            self.ip_addr = self.docker.inspect_container(self.container_id).get('NetworkSettings', {}).get('IPAddress')
            if not self.ip_addr:
                self.logger.error("temporary docker {} not started".format(self.container_id))
                assert False
            self.logger.info("IP addr is {}".format(self.ip_addr))
            self.wait_until_available()
        except APIError as e:
            pytest.exit(
                "error during setup of docker container {}, aborting. Details:\n{}".format(container_name_prefixed,
                                                                                           str(e)))

def pytest_cmdline_main(config):
    """
    Enforce test environment before loading fixtures and running tests
    This helps prevent accidents like creating/dropping the db in a stage/prod
    environment when running the test suite
    """
    if os.environ.get('CONFIG_ENV') != 'test':
        pytest.exit('Please set CONFIG_ENV=test before running test suite')

def exit_if_switch_used_with_xdist(session, switch_list):
    if hasattr(session.config, 'slaveinput'):
        for switch_str in switch_list:
            if session.config.getoption(switch_str):
                pytest.exit(
                    'Cannot use {} when running in parallel under pytest-xdist '
                    '(e.g., -n --dist --tx)'.format(switch_str)
                )

	def prepare_test(dirname, testfile):
		if not os.path.exists(nserv_datadir + '/' + dirname + '.nzb'):
			os.makedirs(nserv_datadir + '/' + dirname)
			shutil.copyfile(testdata_dir + '/rarrenamer/' + testfile + '.part01.rar', nserv_datadir + '/' + dirname + '/abc.21')
			shutil.copyfile(testdata_dir + '/rarrenamer/' + testfile + '.part02.rar', nserv_datadir + '/' + dirname + '/abc.02')
			shutil.copyfile(testdata_dir + '/rarrenamer/' + testfile + '.part03.rar', nserv_datadir + '/' + dirname + '/abc.15')
			os.chdir(nserv_datadir + '/' + dirname)
			if 0 != subprocess.call([par2_bin, 'c', '-b20', 'parrename.par2', '*']):
				pytest.exit('Test file generation failed')

def validate_pytest_config():
  """
  Validate that pytest command line options make sense.
  """
  if pytest.config.option.testing_remote_cluster:
    local_prefixes = ('localhost', '127.', '0.0.0.0')
    if any(pytest.config.option.impalad.startswith(loc) for loc in local_prefixes):
      logging.error("--testing_remote_cluster can not be used with a local impalad")
      pytest.exit("Invalid pytest config option: --testing_remote_cluster")

def pytest_generate_tests(metafunc):
    if 'engine' in metafunc.fixturenames:
        engines = []
        for e in metafunc.config.option.engine.split(','):
            if e in ['theano_engine', 'dict_engine']:
                engines.append(e)
        if not engines:
            pytest.exit("Unknown engine.")
        metafunc.parametrize("engine", engines, scope="session")

def pytest_configure(config):
    "Assert that the environment is correctly configured."

    global topology_only

    if not diagnose_env():
        pytest.exit('enviroment has errors, please read the logs')

    if config.getoption('--topology-only'):
        topology_only = True

def verify_cleanup():
    """Verify that the test has cleaned up resources correctly."""
    yield

    if len(INSTANCES) >= 2:
        count = len(INSTANCES)
        for inst in INSTANCES:
            inst.stop()
        pytest.exit("Detected non stopped instances "
                    "({}), aborting test run".format(count))

def atomic_data_fname(tardis_ref_path):
    atomic_data_fname = os.path.join(
        tardis_ref_path, 'atom_data', 'kurucz_cd23_chianti_H_He.h5')

    atom_data_missing_str = ("{0} atomic datafiles "
                             "does not seem to exist".format(atomic_data_fname))

    if not os.path.exists(atomic_data_fname):
        pytest.exit(atom_data_missing_str)

    return atomic_data_fname

    def check_fullfilled(self):
        try:
            result = self.request_check()
        except SproutException as e:
            # TODO: ensure we only exit this way on sprout usage
            self.destroy_pool()
            log.error("sprout pool could not be fulfilled\n%s", str(e))
            pytest.exit(1)

        log.debug("fulfilled at %f %%", result['progress'])
        return result["fulfilled"]

def pytest_configure():

    # Make sure we are in the correct folder for the test.
    dirname = os.path.split(os.getcwd())[1]
    if not dirname=='Tests':
        pytest.exit("Not running in the Tests folder!")


    # Make sure the data is downloaded
    from ..Scripts import get_data_files
                                                                                
    return           

def handle_existing_list(redis_connection, do_force_deletion, list_key):
    """Clear a list in a redis instance or warns the user about deletion."""
    if redis_connection.llen(list_key):
        if not do_force_deletion:
            exit_string = ("redis list '{}' exists in redis instance. "
                           "pass --force to ignore this and delete "
                           "list.").format(list_key)
            pytest.exit(exit_string)
        else:
            print "Deleting pre-exiting redis list '{}'".format(
                list_key)
            clean_list(redis_connection, list_key)

    def start(self):
        """Start a subprocess

        This method makes python actually spawn the subprocess and wait for it
        to finish initializing.
        """
        self._start_subprocess()

        self._register_stdout_stderr_to_logcatcher()

        if not self._wait_for_subprocess_to_finish_init():
            self.stop()
            pytest.exit("Failed to start `{}` process".format(self.id))

def secrets(request):
    spath = request.config.getoption("--secrets") or "test_options.json"
    fstring = "{}"
    if os.path.exists(spath):
        with open(spath) as f:
            fstring = f.read()

    marshalled, errors = SecretsContainer().loads(fstring)

    if errors:
        pytest.exit("Errors with the secrets container unmarshal")

    return marshalled

def check_required_loopback_interfaces_available():
    """
    We need at least 3 loopback interfaces configured to run almost all dtests. On Linux, loopback
    interfaces are automatically created as they are used, but on Mac they need to be explicitly
    created. Check if we're running on Mac (Darwin), and if so check we have at least 3 loopback
    interfaces available, otherwise bail out so we don't run the tests in a known bad config and
    give the user some helpful advice on how to get their machine into a good known config
    """
    if platform.system() == "Darwin":
        if len(ni.ifaddresses('lo0')[AF_INET]) < 9:
            pytest.exit("At least 9 loopback interfaces are required to run dtests. "
                            "On Mac you can create the required loopback interfaces by running "
                            "'for i in {1..9}; do sudo ifconfig lo0 alias 127.0.0.$i up; done;'")

def pytest_configure(config):
    msgs = []

    if not os.path.exists(_testdata):
        msg = "testdata not available! "
        if os.path.exists(os.path.join(_root, ".git")):
            msg += ("Please run git submodule update --init --recursive " +
                    "and then run tests again.")
        else:
            msg += ("The testdata doesn't appear to be included with this package, " +
                    "so finding the right version will be hard. :(")
        msgs.append(msg)

    if config.option.update_xfail:
        # Check for optional requirements
        req_file = os.path.join(_root, "requirements-optional.txt")
        if os.path.exists(req_file):
            with open(req_file, "r") as fp:
                for line in fp:
                    if (line.strip() and
                        not (line.startswith("-r") or
                             line.startswith("#"))):
                        if ";" in line:
                            spec, marker = line.strip().split(";", 1)
                        else:
                            spec, marker = line.strip(), None
                        req = pkg_resources.Requirement.parse(spec)
                        if marker and not pkg_resources.evaluate_marker(marker):
                            msgs.append("%s not available in this environment" % spec)
                        else:
                            try:
                                installed = pkg_resources.working_set.find(req)
                            except pkg_resources.VersionConflict:
                                msgs.append("Outdated version of %s installed, need %s" % (req.name, spec))
                            else:
                                if not installed:
                                    msgs.append("Need %s" % spec)

        # Check cElementTree
        import xml.etree.ElementTree as ElementTree

        try:
            import xml.etree.cElementTree as cElementTree
        except ImportError:
            msgs.append("cElementTree unable to be imported")
        else:
            if cElementTree.Element is ElementTree.Element:
                msgs.append("cElementTree is just an alias for ElementTree")

    if msgs:
        pytest.exit("\n".join(msgs))