def check_file(dirname): filename = os.path.join(dirname, DEFAULT_LOCAL_STATE_FILENAME) assert os.path.exists(filename) local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state("foobar") assert dict(port=42, shutdown_commands=[["foo"]]) == state local_state_file.set_service_run_state("foobar", dict(port=43, shutdown_commands=[])) local_state_file.save() changed = local_state_file.get_service_run_state("foobar") assert dict(port=43, shutdown_commands=[]) == changed # and we can reload it from scratch local_state_file2 = LocalStateFile.load_for_directory(dirname) changed2 = local_state_file2.get_service_run_state("foobar") assert dict(port=43, shutdown_commands=[]) == changed2
def set_config(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = _redis_requirement() provider = RedisProvider() provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(lower_port="6001")) config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config['lower_port'] == 6001 assert config['upper_port'] == 6449 provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(upper_port="6700")) config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config2['lower_port'] == 6001 assert config2['upper_port'] == 6700 provider.set_config_values_as_strings( requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(lower_port="5500", upper_port="6800")) config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config2['lower_port'] == 5500 assert config2['upper_port'] == 6800
def _internal_prepare_in_stages(project, environ_copy, overrides, keep_going_until_success, mode, provide_whitelist, command_name, command, extra_command_args): assert not project.problems if mode not in _all_provide_modes: raise ValueError("invalid provide mode " + mode) assert not (command_name is not None and command is not None) assert command_name is None or command_name in project.commands assert overrides.env_spec_name is None or overrides.env_spec_name in project.env_specs if command is None: command = project.command_for_name(command_name) # at this point, "command" is only None if there are no # commands for this project. local_state = LocalStateFile.load_for_directory(project.directory_path) statuses = [] for requirement in project.requirements: status = requirement.check_status( environ_copy, local_state, project.default_env_spec_name_for_command(command), overrides, latest_provide_result=None) statuses.append(status) return _first_stage(project, environ_copy, local_state, statuses, keep_going_until_success, mode, provide_whitelist, overrides, command, extra_command_args)
def _internal_prepare_in_stages(project, environ_copy, overrides, keep_going_until_success, mode, provide_whitelist, command_name, command, extra_command_args): assert not project.problems if mode not in _all_provide_modes: raise ValueError("invalid provide mode " + mode) assert not (command_name is not None and command is not None) assert command_name is None or command_name in project.commands assert overrides.env_spec_name is None or overrides.env_spec_name in project.env_specs if command is None: command = project.command_for_name(command_name) # at this point, "command" is only None if there are no # commands for this project. local_state = LocalStateFile.load_for_directory(project.directory_path) statuses = [] for requirement in project.requirements: status = requirement.check_status(environ_copy, local_state, project.default_env_spec_name_for_command(command), overrides, latest_provide_result=None) statuses.append(status) return _first_stage(project, environ_copy, local_state, statuses, keep_going_until_success, mode, provide_whitelist, overrides, command, extra_command_args)
def do_test(dirname): io_loop = IOLoop() io_loop.make_current() events = [] def event_handler(event): events.append(event) project = Project(dirname) local_state_file = LocalStateFile.load_for_directory(dirname) context = ConfigurePrepareContext(dict(), local_state_file, 'default', UserConfigOverrides(), []) server = UIServer(project, _no_op_prepare(context), event_handler, io_loop) get_response = http_get(io_loop, server.url) print(repr(get_response)) post_response = http_post(io_loop, server.url, body="") print(repr(post_response)) server.unlisten() assert len(events) == 1 assert isinstance(events[0], UIServerDoneEvent)
def unset_variables(project, vars_to_unset, env_spec_name=None): """Unset variables' values in kapsel-local.yml. Returns a ``Status`` instance which evaluates to True on success and has an ``errors`` property (with a list of error strings) on failure. Args: project (Project): the project vars_to_unset (list of str): variable names env_spec_name (str): name of env spec to use Returns: ``Status`` instance """ (env_prefix, status) = _prepare_env_prefix(project, env_spec_name) if env_prefix is None: return status local_state = LocalStateFile.load_for_directory(project.directory_path) for varname in vars_to_unset: _unset_variable(project, env_prefix, varname, local_state) local_state.save() return SimpleStatus(success=True, description=("Variables were unset."))
def set_config(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = _redis_requirement() provider = RedisProvider() provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(lower_port="6001")) config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config['lower_port'] == 6001 assert config['upper_port'] == 6449 provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(upper_port="6700")) config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config2['lower_port'] == 6001 assert config2['upper_port'] == 6700 provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(), dict(lower_port="5500", upper_port="6800")) config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert config2['lower_port'] == 5500 assert config2['upper_port'] == 6800
def remove_variables(project, vars_to_remove, env_spec_name=None): """Remove variables from kapsel.yml and unset their values in local project state. Returns a ``Status`` instance which evaluates to True on success and has an ``errors`` property (with a list of error strings) on failure. Args: project (Project): the project vars_to_remove (list of str): variable names env_spec_name (str): name of env spec to use Returns: ``Status`` instance """ (env_prefix, status) = _prepare_env_prefix(project, env_spec_name) if env_prefix is None: return status local_state = LocalStateFile.load_for_directory(project.directory_path) for varname in vars_to_remove: _unset_variable(project, env_prefix, varname, local_state) project.project_file.unset_value(['variables', varname]) project.project_file.save() local_state.save() return SimpleStatus(success=True, description="Variables removed from the project file.")
def check_env_var_provider_config_local_state(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO_PASSWORD") assert requirement.encrypted local_state_file = LocalStateFile.load_for_directory(dirname) status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) assert dict(source='unset') == status.analysis.config assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None assert set(keyring.fallback_data().values()) == set() environ = dict(CONDA_DEFAULT_ENV='/pretend/env', CONDA_ENV_PATH='/pretend/env', CONDA_PREFIX='/pretend/env') provider.set_config_values_as_strings(requirement, environ, local_state_file, 'default', UserConfigOverrides(), dict(value="bar")) # should not have affected local state, should use keyring assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None assert set(keyring.fallback_data().values()) == set(["bar"]) # setting empty string = unset provider.set_config_values_as_strings(requirement, environ, local_state_file, 'default', UserConfigOverrides(), dict(value="")) assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None assert set(keyring.fallback_data().values()) == set()
def prepare_with_browser(dirname): project = project_no_dedicated_env(dirname) environ = minimal_environ() result = prepare_with_browser_ui(project, environ=environ, keep_going_until_success=False, io_loop=io_loop) assert result assert dict(FOO_PASSWORD='******', PROJECT_DIR=project.directory_path) == strip_environ(result.environ) assert dict() == strip_environ(environ) # wait for the results of the POST to come back, # awesome hack-tacular while 'post_fill_in_password' not in http_results: io_loop.call_later(0.01, lambda: io_loop.stop()) io_loop.start() assert 'get_click_submit' in http_results assert 'post_click_submit' in http_results assert 'post_fill_in_password' in http_results assert 200 == http_results['get_click_submit'].code assert 200 == http_results['post_click_submit'].code assert 200 == http_results['post_fill_in_password'].code final_done_html = str(http_results['post_fill_in_password'].body) assert "Done!" in final_done_html assert "Environment variable FOO_PASSWORD is set." in final_done_html local_state_file = LocalStateFile.load_for_directory(project.directory_path) assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = test_redis_provider._prepare_printing_errors(project, environ=minimal_environ()) assert result local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state('REDIS_URL') assert 'port' in state port = state['port'] assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ(result.environ) assert len(can_connect_args_list) >= 2 pidfile = os.path.join(dirname, "services/REDIS_URL/redis.pid") logfile = os.path.join(dirname, "services/REDIS_URL/redis.log") assert os.path.exists(pidfile) assert os.path.exists(logfile) assert real_can_connect_to_socket(host='localhost', port=port) # now clean it up code = _parse_args_and_run_subcommand(['conda-kapsel', 'remove-service', 'REDIS_URL', '--directory', dirname]) assert code == 0 assert not os.path.exists(pidfile) assert not os.path.exists(os.path.join(dirname, "services")) assert not real_can_connect_to_socket(host='localhost', port=port) local_state_file.load() assert dict() == local_state_file.get_service_run_state("REDIS_URL")
def check(dirname): project_dir_disable_dedicated_env(dirname) def mock_is_interactive(): return True monkeypatch.setattr( 'conda_kapsel.commands.console_utils.stdin_is_interactive', mock_is_interactive) inputs = [" ", "foo", "bar"] def mock_console_input(prompt, encrypted): return inputs.pop(0) monkeypatch.setattr( 'conda_kapsel.commands.console_utils.console_input', mock_console_input) res = _parse_args_and_run_subcommand( ['conda-kapsel', 'prepare', '--directory', dirname]) assert res == 0 local_state = LocalStateFile.load_for_directory(dirname) assert local_state.get_value(['variables', 'FOO']) == 'foo' assert local_state.get_value(['variables', 'BAR']) == 'bar'
def read_config(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = _redis_requirement() provider = RedisProvider() config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) assert 6380 == config['lower_port'] assert 6449 == config['upper_port']
def check_env_var_provider_config(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO") local_state_file = LocalStateFile.load_for_directory(dirname) environ = dict() config = provider.read_config(requirement, environ, local_state_file, 'default', UserConfigOverrides()) assert dict(source='unset') == config # config html when variable is unset status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status) assert "Keep" not in html assert 'Use this value:' in html # config html when variable is unset and we have a default requirement.options['default'] = 'from_default' status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status) assert "Keep default 'from_default'" in html assert 'Use this value instead:' in html # config html when variable is set environ = dict(FOO='from_environ') status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides()) html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status) assert "Keep value 'from_environ'" in html assert 'Use this value instead:' in html # config html when local state override is present environ = dict(FOO='from_environ') local_state_file.set_value(['variables', 'FOO'], 'from_local_state') status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides()) html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status) assert "Keep value 'from_environ'" in html assert 'Use this value instead:' in html
def check_env_var_provider_config_disabled_local_state(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO") local_state_file = LocalStateFile.load_for_directory(dirname) status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) assert dict(source='unset') == status.analysis.config assert local_state_file.get_value(['variables', 'FOO']) is None assert local_state_file.get_value(['disabled_variables', 'FOO']) is None environ = dict() # source=environ should mean we set disabled_variables instead of variables provider.set_config_values_as_strings(requirement, environ, local_state_file, 'default', UserConfigOverrides(), dict(source='environ', value="bar")) assert local_state_file.get_value(['variables', 'FOO']) is None assert local_state_file.get_value(['disabled_variables', 'FOO']) == "bar" config = provider.read_config(requirement, environ, local_state_file, 'default', UserConfigOverrides()) assert config == dict(source='unset', value='bar')
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result assert 'REDIS_URL' in result.environ local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state("REDIS_URL") assert 'port' in state port = state['port'] assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ( result.environ) assert len(can_connect_args_list) >= 2 pidfile = os.path.join(dirname, "services/REDIS_URL/redis.pid") logfile = os.path.join(dirname, "services/REDIS_URL/redis.log") assert os.path.exists(pidfile) assert os.path.exists(logfile) assert real_can_connect_to_socket(host='localhost', port=port) # be sure we generate the config html that would use the old one requirement = _redis_requirement() status = requirement.check_status(result.environ, local_state_file, 'default', UserConfigOverrides()) html = RedisProvider().config_html(requirement, result.environ, local_state_file, UserConfigOverrides(), status) assert 'Use the redis-server we started earlier' in html # now try again, and we should re-use the exact same server pidfile_mtime = os.path.getmtime(pidfile) with codecs.open(pidfile, 'r', 'utf-8') as file: pidfile_content = file.read() result2 = _prepare_printing_errors(project, environ=minimal_environ()) assert result2 # port should be the same, and set in the environment assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ( result2.environ) # no new pid file assert pidfile_mtime == os.path.getmtime(pidfile) with codecs.open(pidfile, 'r', 'utf-8') as file: pidfile_content2 = file.read() assert pidfile_content == pidfile_content2 # now clean it up status = unprepare(project, result2) assert status assert not os.path.exists(pidfile) assert not real_can_connect_to_socket(host='localhost', port=port) local_state_file.load() assert dict() == local_state_file.get_service_run_state("REDIS_URL")
def tmp_local_state_file(): import tempfile # delete=False required so windows will allow the file to be opened f = tempfile.NamedTemporaryFile(dir=local_tmp, delete=False) local_state = LocalStateFile(f.name) f.close() os.remove(f.name) return local_state
def check_not_set(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = DownloadRequirement(registry=PluginRegistry(), env_var=ENV_VAR, url='http://example.com', filename=ENV_VAR) status = requirement.check_status(dict(PROJECT_DIR=dirname), local_state, 'default', UserConfigOverrides()) assert not status assert "Environment variable {} is not set.".format(ENV_VAR) == status.status_description
def check(dirname): local_state_file = LocalStateFile.load_for_directory(dirname) true_commandline = tmp_script_commandline("""import sys sys.exit(0) """) local_state_file.set_service_run_state('FOO', {'shutdown_commands': [true_commandline]}) status = shutdown_service_run_state(local_state_file, 'FOO') assert status assert status.status_description == "Successfully shut down FOO."
def check_bad_scheme(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = RedisRequirement(registry=PluginRegistry(), env_var="REDIS_URL") status = requirement.check_status( dict(REDIS_URL="http://example.com/"), local_state, 'default', UserConfigOverrides()) assert not status assert "REDIS_URL value 'http://example.com/' does not have 'redis:' scheme." == status.status_description
def check_conda_default_env_is_bogus(dirname): requirement = _empty_default_requirement() project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) status = requirement.check_status( minimal_environ_no_conda_env(**{'PROJECT_DIR': dirname}), local_state, 'default', UserConfigOverrides(inherited_env="not_a_real_env_anyone_has")) expected = "'not_a_real_env_anyone_has' doesn't look like it contains a Conda environment yet." assert expected == status.status_description
def check(dirname): local_state_file = LocalStateFile.load_for_directory(dirname) false_commandline = tmp_script_commandline("""import sys sys.exit(1) """) local_state_file.set_service_run_state('FOO', {'shutdown_commands': [false_commandline]}) status = shutdown_service_run_state(local_state_file, 'FOO') assert not status assert status.status_description == "Shutdown commands failed for FOO." assert status.errors == ["Shutting down FOO, command %r failed with code 1." % false_commandline]
def check_file(dirname): filename = os.path.join(dirname, DEFAULT_LOCAL_STATE_FILENAME) assert os.path.exists(filename) local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state("foo") assert dict(port=42) == state state = local_state_file.get_service_run_state("bar") assert dict(port=43) == state states = local_state_file.get_all_service_run_states() assert dict(foo=dict(port=42), bar=dict(port=43)) == states
def check_conda_default_env_not_set(dirname): requirement = _empty_default_requirement() project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) status = requirement.check_status( minimal_environ_no_conda_env(PROJECT_DIR=dirname), local_state, 'default', UserConfigOverrides()) expected = "'{}' doesn't look like it contains a Conda environment yet.".format( os.path.join(dirname, 'envs', 'default')) assert expected == status.status_description
def set_variables(project, vars_and_values, env_spec_name=None): """Set variables' values in kapsel-local.yml. Returns a ``Status`` instance which evaluates to True on success and has an ``errors`` property (with a list of error strings) on failure. Args: project (Project): the project vars_and_values (list of tuple): key-value pairs env_spec_name (str): name of env spec to use Returns: ``Status`` instance """ (env_prefix, status) = _prepare_env_prefix(project, env_spec_name) if env_prefix is None: return status local_state = LocalStateFile.load_for_directory(project.directory_path) var_reqs = dict() for req in project.find_requirements(klass=EnvVarRequirement): var_reqs[req.env_var] = req present_vars = set(var_reqs.keys()) errors = [] local_state_count = 0 keyring_count = 0 for varname, value in vars_and_values: if varname in present_vars: if var_reqs[varname].encrypted: keyring.set(env_prefix, varname, value) keyring_count = keyring_count + 1 else: local_state.set_value(['variables', varname], value) local_state_count = local_state_count + 1 else: errors.append("Variable %s does not exist in the project." % varname) if errors: return SimpleStatus(success=False, description="Could not set variables.", errors=errors) else: if local_state_count > 0: local_state.save() if keyring_count == 0: description = ("Values saved in %s." % local_state.filename) elif local_state_count == 0: description = ("Values saved in the system keychain.") else: description = ( "%d values saved in %s, %d values saved in the system keychain." % (local_state_count, local_state.filename, keyring_count)) return SimpleStatus(success=True, description=description)
def set_variables(project, vars_and_values, env_spec_name=None): """Set variables' values in kapsel-local.yml. Returns a ``Status`` instance which evaluates to True on success and has an ``errors`` property (with a list of error strings) on failure. Args: project (Project): the project vars_and_values (list of tuple): key-value pairs env_spec_name (str): name of env spec to use Returns: ``Status`` instance """ (env_prefix, status) = _prepare_env_prefix(project, env_spec_name) if env_prefix is None: return status local_state = LocalStateFile.load_for_directory(project.directory_path) var_reqs = dict() for req in project.find_requirements(klass=EnvVarRequirement): var_reqs[req.env_var] = req present_vars = set(var_reqs.keys()) errors = [] local_state_count = 0 keyring_count = 0 for varname, value in vars_and_values: if varname in present_vars: if var_reqs[varname].encrypted: # import keyring locally because it's an optional dependency # that prints a warning when it's needed but not found. from conda_kapsel.internal import keyring keyring.set(env_prefix, varname, value) keyring_count = keyring_count + 1 else: local_state.set_value(['variables', varname], value) local_state_count = local_state_count + 1 else: errors.append("Variable %s does not exist in the project." % varname) if errors: return SimpleStatus(success=False, description="Could not set variables.", errors=errors) else: if local_state_count > 0: local_state.save() if keyring_count == 0: description = ("Values saved in %s." % local_state.filename) elif local_state_count == 0: description = ("Values saved in the system keychain.") else: description = ("%d values saved in %s, %d values saved in the system keychain." % (local_state_count, local_state.filename, keyring_count)) return SimpleStatus(success=True, description=description)
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result assert 'REDIS_URL' in result.environ local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state("REDIS_URL") assert 'port' in state port = state['port'] assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ(result.environ) assert len(can_connect_args_list) >= 2 pidfile = os.path.join(dirname, "services/REDIS_URL/redis.pid") logfile = os.path.join(dirname, "services/REDIS_URL/redis.log") assert os.path.exists(pidfile) assert os.path.exists(logfile) assert real_can_connect_to_socket(host='localhost', port=port) # be sure we generate the config html that would use the old one requirement = _redis_requirement() status = requirement.check_status(result.environ, local_state_file, 'default', UserConfigOverrides()) html = RedisProvider().config_html(requirement, result.environ, local_state_file, UserConfigOverrides(), status) assert 'Use the redis-server we started earlier' in html # now try again, and we should re-use the exact same server pidfile_mtime = os.path.getmtime(pidfile) with codecs.open(pidfile, 'r', 'utf-8') as file: pidfile_content = file.read() result2 = _prepare_printing_errors(project, environ=minimal_environ()) assert result2 # port should be the same, and set in the environment assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ(result2.environ) # no new pid file assert pidfile_mtime == os.path.getmtime(pidfile) with codecs.open(pidfile, 'r', 'utf-8') as file: pidfile_content2 = file.read() assert pidfile_content == pidfile_content2 # now clean it up status = unprepare(project, result2) assert status assert not os.path.exists(pidfile) assert not real_can_connect_to_socket(host='localhost', port=port) local_state_file.load() assert dict() == local_state_file.get_service_run_state("REDIS_URL")
def downloaded_file_valid(dirname): local_state = LocalStateFile.load_for_directory(dirname) filename = os.path.join(dirname, 'data.zip') requirement = DownloadRequirement(registry=PluginRegistry(), env_var=ENV_VAR, url='http://localhost/data.zip', filename='data.zip') status = requirement.check_status({ENV_VAR: filename, 'PROJECT_DIR': dirname}, local_state, 'default', UserConfigOverrides()) assert status assert 'File downloaded to {}'.format(filename) == status.status_description
def check_missing_filename(dirname): local_state = LocalStateFile.load_for_directory(dirname) filename = '/data.zip' requirement = DownloadRequirement(registry=PluginRegistry(), env_var=ENV_VAR, url='http://localhost/data.zip', filename='data.zip') status = requirement.check_status({ENV_VAR: filename, 'PROJECT_DIR': dirname}, local_state, 'default', UserConfigOverrides()) assert not status assert 'File not found: {}'.format(filename) == status.status_description
def read_config(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = _redis_requirement() provider = RedisProvider() config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides()) # revert to defaults assert 6380 == config['lower_port'] assert 6449 == config['upper_port'] # should have printed an error out, err = capsys.readouterr() assert ("Invalid port_range '%s', should be like '6380-6449'\n" % (port_range)) == err
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result # now clean it up, but arrange for that to fail local_state_file = LocalStateFile.load_for_directory(dirname) local_state_file.set_service_run_state('REDIS_URL', {'shutdown_commands': [['false']]}) local_state_file.save() status = unprepare(project, result) assert not status assert status.status_description == 'Shutdown commands failed for REDIS_URL.'
def check_missing_package(dirname): requirement = CondaEnvRequirement( registry=PluginRegistry(), env_specs=dict(default=EnvSpec( 'default', ['boguspackage', 'boguspackage2'], []))) project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) environ = minimal_environ(PROJECT_DIR=dirname) status = requirement.check_status( environ, local_state, 'default', UserConfigOverrides(inherited_env=environ.get(conda_env_var))) assert "Conda environment is missing packages: boguspackage, boguspackage2" == status.status_description
def check_missing_package(dirname): requirement = CondaEnvRequirement( registry=PluginRegistry(), env_specs=dict(default=EnvSpec('default', ['boguspackage', 'boguspackage2'], []))) project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) environ = minimal_environ(PROJECT_DIR=dirname) status = requirement.check_status(environ, local_state, 'default', UserConfigOverrides(inherited_env=environ.get(conda_env_var))) assert "Conda environment is missing packages: boguspackage, boguspackage2" == status.status_description
def check_provide_contents(dirname): environ = dict(foo='bar') local_state_file = LocalStateFile.load_for_directory(dirname) requirement = EnvVarRequirement(PluginRegistry(), env_var="FOO") status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides()) context = ProvideContext(environ=environ, local_state_file=local_state_file, default_env_spec_name='default', status=status, mode=PROVIDE_MODE_DEVELOPMENT) assert dict(foo='bar') == context.environ assert context.status is status
def check_conda_default_env_not_set(dirname): requirement = _empty_default_requirement() project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) status = requirement.check_status( minimal_environ_no_conda_env(PROJECT_DIR=dirname), local_state, 'default', UserConfigOverrides()) expected = "'{}' doesn't look like it contains a Conda environment yet.".format(os.path.join(dirname, 'envs', 'default')) assert expected == status.status_description
def do_test(dirname): io_loop = IOLoop() io_loop.make_current() events = [] def event_handler(event): events.append(event) project = Project(dirname) local_state_file = LocalStateFile.load_for_directory(dirname) requirement = EnvVarRequirement(registry=project.plugin_registry, env_var="FOO") status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) context = ConfigurePrepareContext(dict(), local_state_file, 'default', UserConfigOverrides(), [status]) server = UIServer(project, _no_op_prepare(context), event_handler, io_loop) # do a get so that _requirements_by_id below exists get_response = http_get(io_loop, server.url) assert 200 == get_response.code req_id = list(server._application._requirements_by_id.keys())[0] if '%s' in name_template: name = name_template % req_id else: name = name_template encoder = MultipartEncoder({name: 'bloop'}) body = encoder.to_string() headers = {'Content-Type': encoder.content_type} post_response = http_post(io_loop, server.url, body=body, headers=headers) # we just ignore bad form names, because they are assumed # to be some sort of hostile thing. we shouldn't ever # generate them on purpose. assert 200 == post_response.code server.unlisten() assert len(events) == 1 assert isinstance(events[0], UIServerDoneEvent) out, err = capsys.readouterr() assert out == "" assert err == expected_err
def check_provide_contents(dirname): environ = dict() local_state_file = LocalStateFile.load_for_directory(dirname) requirement = EnvVarRequirement(PluginRegistry(), env_var="FOO") status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides()) context = ProvideContext(environ=environ, local_state_file=local_state_file, default_env_spec_name='default', status=status, mode=PROVIDE_MODE_DEVELOPMENT) with pytest.raises(IOError) as excinfo: context.ensure_service_directory("foo") assert "this is not EEXIST" in repr(excinfo.value)
def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) local_state = LocalStateFile.load_for_directory(dirname) local_state.set_service_run_state('TEST', {'shutdown_commands': [_echo_commandline + ['"shutting down TEST"']]}) local_state.save() code = _parse_args_and_run_subcommand(['conda-kapsel', 'remove-service', 'redis']) assert code == 0 out, err = capsys.readouterr() assert '' == err expected_out = ("Removed service 'redis' from the project file.\n") assert expected_out == out
def check_env_var_provider(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO") local_state_file = LocalStateFile.load_for_directory(dirname) status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) context = ProvideContext(environ=dict(), local_state_file=local_state_file, default_env_spec_name='default', status=status, mode=PROVIDE_MODE_DEVELOPMENT) provider.provide(requirement, context=context) assert 'FOO' not in context.environ
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result # now clean it up, but arrange for that to fail local_state_file = LocalStateFile.load_for_directory(dirname) local_state_file.set_service_run_state( 'REDIS_URL', {'shutdown_commands': [['false']]}) local_state_file.save() status = unprepare(project, result) assert not status assert status.status_description == 'Shutdown commands failed for REDIS_URL.'
def provide_download(dirname): FILENAME = os.path.join(dirname, 'data.csv') requirement = _download_requirement() local_state_file = LocalStateFile.load_for_directory(dirname) local_state_file.set_service_run_state(requirement.env_var, {'filename': FILENAME}) local_state_file.save() with open(FILENAME, 'w') as out: out.write('data') project = project_no_dedicated_env(dirname) result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname)) assert hasattr(result, 'environ') assert 'DATAFILE' in result.environ
def create_file(dirname): filename = os.path.join(dirname, DEFAULT_LOCAL_STATE_FILENAME) assert not os.path.exists(filename) local_state_file = LocalStateFile.load_for_directory(dirname) assert local_state_file is not None assert not os.path.exists(filename) local_state_file.save() assert os.path.exists(filename) with codecs.open(filename, 'r', 'utf-8') as file: contents = file.read() # this is sort of annoying that the default empty file # has {} in it, but in our real usage we should only # save the file if we set something in it probably. assert "# Anaconda local project state (specific to this user/machine)\n{}\n" == contents
def check_env_var_provider_config_local_state(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO") local_state_file = LocalStateFile.load_for_directory(dirname) status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) assert dict(source='unset') == status.analysis.config assert local_state_file.get_value(['variables', 'FOO']) is None environ = dict() provider.set_config_values_as_strings(requirement, environ, local_state_file, 'default', UserConfigOverrides(), dict(value="bar")) assert local_state_file.get_value(['variables', 'FOO']) == "bar" local_state_file.save() local_state_file_2 = LocalStateFile.load_for_directory(dirname) assert local_state_file_2.get_value(['variables', 'FOO']) == "bar" # setting empty string = unset provider.set_config_values_as_strings(requirement, environ, local_state_file, 'default', UserConfigOverrides(), dict(value="")) assert local_state_file.get_value(['variables', 'FOO']) is None local_state_file.save() local_state_file_3 = LocalStateFile.load_for_directory(dirname) assert local_state_file_3.get_value(['variables', 'FOO']) is None
def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) local_state = LocalStateFile.load_for_directory(dirname) local_state.set_service_run_state('ABC', {'shutdown_commands': [_echo_commandline + ['"shutting down ABC"']]}) local_state.set_service_run_state('TEST', {'shutdown_commands': [_echo_commandline + ['"shutting down TEST"']]}) local_state.save() code = _parse_args_and_run_subcommand(['conda-kapsel', 'remove-service', 'redis']) assert code == 1 out, err = capsys.readouterr() assert '' == out expected_err = ("Conflicting results, found 2 matches, use list-services" " to identify which service you want to remove\n") assert expected_err == err
def check_cannot_connect(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = RedisRequirement(registry=PluginRegistry(), env_var="REDIS_URL") can_connect_args_list = _monkeypatch_can_connect_to_socket_fails(monkeypatch) status = requirement.check_status( dict(REDIS_URL="redis://example.com:1234/"), local_state, 'default', UserConfigOverrides()) assert dict(host='example.com', port=1234, timeout_seconds=0.5) == can_connect_args_list[0] assert dict(host='localhost', port=6379, timeout_seconds=0.5) == can_connect_args_list[1] assert not status expected = "Cannot connect to Redis at redis://example.com:1234/." assert expected == status.status_description
def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) local_state = LocalStateFile.load_for_directory(dirname) false_commandline = tmp_script_commandline("""import sys sys.exit(1) """) local_state.set_service_run_state('TEST', {'shutdown_commands': [false_commandline]}) local_state.save() code = _parse_args_and_run_subcommand(['conda-kapsel', 'remove-service', 'TEST']) assert code == 1 out, err = capsys.readouterr() expected_err = ("Shutting down TEST, command %r failed with code 1.\n" + "Shutdown commands failed for TEST.\n") % false_commandline assert expected_err == err assert '' == out
def config_html(dirname): FILENAME = os.path.join(dirname, 'data.csv') local_state_file = LocalStateFile.load_for_directory(dirname) requirement = _download_requirement() environ = minimal_environ(PROJECT_DIR=dirname) status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides()) provider = DownloadProvider() html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status) assert 'Download {} to {}'.format(requirement.url, requirement.filename) in html with open(FILENAME, 'w') as f: f.write('boo') env = minimal_environ(PROJECT_DIR=dirname) status = requirement.check_status(env, local_state_file, 'default', UserConfigOverrides()) html = provider.config_html(requirement, env, local_state_file, UserConfigOverrides(), status) expected_choice = 'Use already-downloaded file {}'.format(FILENAME) assert expected_choice in html
def check_fails_while_listing_installed(dirname): def sabotaged_installed_command(prefix): from conda_kapsel.internal import conda_api raise conda_api.CondaError("sabotage!") monkeypatch.setattr('conda_kapsel.internal.conda_api.installed', sabotaged_installed_command) project_dir_disable_dedicated_env(dirname) local_state = LocalStateFile.load_for_directory(dirname) requirement = CondaEnvRequirement(registry=PluginRegistry(), env_specs=dict(default=EnvSpec('default', ['not_a_real_package'], []))) environ = minimal_environ(PROJECT_DIR=dirname) status = requirement.check_status(environ, local_state, 'default', UserConfigOverrides(inherited_env=environ.get(conda_env_var))) assert status.status_description.startswith("Conda failed while listing installed packages in ") assert status.status_description.endswith(": sabotage!")
def do_test(dirname): io_loop = IOLoop() io_loop.make_current() events = [] def event_handler(event): events.append(event) local_state_file = LocalStateFile.load_for_directory(dirname) value = local_state_file.get_value(['variables', 'FOO']) assert value is None project = Project(dirname) requirement = EnvVarRequirement(registry=project.plugin_registry, env_var="FOO") status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) context = ConfigurePrepareContext(dict(), local_state_file, 'default', UserConfigOverrides(), [status]) server = UIServer(project, _no_op_prepare(context), event_handler, io_loop) get_response = http_get(io_loop, server.url) print(repr(get_response)) soup = BeautifulSoup(get_response.body, _BEAUTIFUL_SOUP_BACKEND) field = soup.find_all("input", attrs={'type': 'text'})[0] assert 'name' in field.attrs encoder = MultipartEncoder({field['name']: 'bloop'}) body = encoder.to_string() headers = {'Content-Type': encoder.content_type} post_response = http_post(io_loop, server.url, body=body, headers=headers) print(repr(post_response)) server.unlisten() assert len(events) == 1 assert isinstance(events[0], UIServerDoneEvent) value = local_state_file.get_value(['variables', 'FOO']) assert 'bloop' == value
def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result local_state_file = LocalStateFile.load_for_directory(dirname) state = local_state_file.get_service_run_state('REDIS_URL') assert 'port' in state port = state['port'] assert dict(REDIS_URL=("redis://localhost:" + str(port)), PROJECT_DIR=project.directory_path) == strip_environ(result.environ) assert len(can_connect_args_list) >= 2 servicedir = os.path.join(dirname, "services") redisdir = os.path.join(servicedir, "REDIS_URL") pidfile = os.path.join(redisdir, "redis.pid") logfile = os.path.join(redisdir, "redis.log") assert os.path.exists(pidfile) assert os.path.exists(logfile) assert real_can_connect_to_socket(host='localhost', port=port) # now clean it up status = unprepare(project, result) assert status assert not os.path.exists(pidfile) assert not os.path.exists(logfile) assert not os.path.exists(redisdir) assert not os.path.exists(servicedir) assert not real_can_connect_to_socket(host='localhost', port=port) local_state_file.load() assert dict() == local_state_file.get_service_run_state("REDIS_URL")
def project_dir_disable_dedicated_env(dirname): """Modify project config to disable having a dedicated environment.""" local_state = LocalStateFile.load_for_directory(dirname) local_state.set_value('inherit_environment', True) local_state.save()