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