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_provide_contents(dirname): environ = dict() local_state_file = LocalStateFile.load_for_directory(dirname) local_state_file.set_service_run_state("myservice", dict(port=42)) requirement = EnvVarRequirement(RequirementsRegistry(), 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, frontend=NullFrontend()) def transform_it(state): assert 42 == state['port'] state['port'] = 43 state['foo'] = 'bar' return 1234 result = context.transform_service_run_state("myservice", transform_it) assert 1234 == result assert dict( port=43, foo='bar') == local_state_file.get_service_run_state("myservice")
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 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 check(dirname): project_dir_disable_dedicated_env(dirname) def mock_is_interactive(): return True monkeypatch.setattr( 'anaconda_project.internal.cli.console_utils.stdin_is_interactive', mock_is_interactive) inputs = [" ", "foo", "bar"] def mock_console_input(prompt, encrypted): return inputs.pop(0) monkeypatch.setattr( 'anaconda_project.internal.cli.console_utils.console_input', mock_console_input) res = _parse_args_and_run_subcommand( ['anaconda-project', '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 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 remove_variables(project, vars_to_remove, env_spec_name=None): """Remove variables from anaconda-project.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 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 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 unset_variables(project, vars_to_unset, env_spec_name=None): """Unset variables' values in anaconda-project-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 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.errors == [] 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 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 check_bad_scheme(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = RedisRequirement(registry=RequirementsRegistry(), 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 set_variables(project, vars_and_values, env_spec_name=None): """Set variables' values in anaconda-project-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 anaconda_project.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 check_not_set(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = RedisRequirement(registry=PluginRegistry(), env_var="REDIS_URL") status = requirement.check_status(dict(), local_state, 'default', UserConfigOverrides()) assert not status assert "Environment variable REDIS_URL is not set." == status.status_description
def check_file(dirname): filename = os.path.join(dirname, relative_name) assert os.path.exists(filename) subdir = os.path.join(dirname, 'subdir') os.makedirs(subdir) local_state_file = LocalStateFile.load_for_directory(subdir) state = local_state_file.get_service_run_state("foobar") assert dict(port=42, shutdown_commands=[["foo"]]) == state
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_not_set(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = DownloadRequirement(registry=RequirementsRegistry(), 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_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 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_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(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 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()) # 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 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_cannot_connect(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = RedisRequirement(registry=RequirementsRegistry(), 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_missing_package(dirname): requirement = CondaEnvRequirement( registry=RequirementsRegistry(), 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 prepare_after_setting_scope(dirname): local_state = LocalStateFile.load_for_directory(dirname) requirement = _redis_requirement() provider = RedisProvider() environ = minimal_environ() config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'find_all' provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='find_project')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'find_project' provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='find_all')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'find_all' provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='environ')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'find_all' # default if no env var set provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='environ')) environ_with_redis_url = environ.copy() environ_with_redis_url['REDIS_URL'] = 'blah' config = provider.read_config(requirement, environ_with_redis_url, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'environ' # default when the env var IS set # use local variable when env var not set provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='variables', value='foo')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'variables' assert config['value'] == 'foo' # use local variable when env var _is_ set provider.set_config_values_as_strings(requirement, environ_with_redis_url, local_state, 'default', UserConfigOverrides(), dict(source='variables', value='foo')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'variables' assert config['value'] == 'foo' # set to use system, which should override using the local state provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(), dict(source='find_system')) config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides()) assert config['source'] == 'find_system' project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result assert dict( REDIS_URL="redis://localhost:6379", PROJECT_DIR=project.directory_path) == strip_environ(result.environ) assert dict(host='localhost', port=6379, timeout_seconds=0.5) == can_connect_args
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(['anaconda-project', '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_provide_contents(dirname): environ = dict(foo='bar') local_state_file = LocalStateFile.load_for_directory(dirname) requirement = EnvVarRequirement(RequirementsRegistry(), 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, frontend=NullFrontend()) assert dict(foo='bar') == context.environ assert context.status is status