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 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 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 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 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 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 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 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_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_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 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 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 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 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 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 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()
