def _login():
"""Logs in with the provided credentials. Prompts the user for a password if no password is found in the config."""
global _password, _token
if not _password:
_password = _ask_password()
try:
io.debug('Logging in as user {}'.format(_username))
response = requests.post(api.login(),
headers={'Content-Type': 'application/json'},
data=json.dumps({
"username": _username,
"password": _password
}))
response.raise_for_status()
_token = response.json()['token']
except HTTPError as e:
if e.response.status_code == 401:
raise McmdError('Invalid login credentials')
else:
raise McmdError(str(e))
finally:
if not _as_user:
config.set_token(_token)
def _prepare_files_for_upload(paths, names, valid_content_types):
"""
_prepare_files_for_upload takes the paths to the files to upload, the names of them and a list of valid content
types to translate to content types and generates a dictionary which can be uploaded in a post request
:param paths: a list of paths to the files to upload
:param names: the names of files to upload
:param valid_content_types: set of the possible valid content types
:return: a dictionary with as key the name of the file and as value a tuple with: filename, file to upload, and
content type
:exception McmdError when the file on the given path does not exist and when the content type of the file is
invalid.
"""
files = {}
for name, path in zip(names, paths):
file_name = file_utils.get_file_name_from_path(path)
content_type = mimetypes.guess_type(path)[0]
if not os_path.exists(path):
raise McmdError('File [{}] does not exist on path [{}]'.format(
file_name, path.strip(file_name)))
elif content_type in valid_content_types:
try:
files[name] = (file_name, open(path, 'rb'), content_type)
except FileNotFoundError:
raise McmdError('File [{}] does not exist on path [{}]'.format(
file_name, path.strip(file_name)))
else:
raise McmdError('File [{}] does not have valid content type [{}], '
'content type should be in {}'.format(
file_name, content_type, valid_content_types))
return files
def _include_group_role(subject: Role, target_role: Role):
if not target_role.group:
raise McmdError('Role {} is not a group role'.format(target_role.name))
if subject.name == target_role.name:
raise McmdError("A role can't include itself")
io.start('Including role {} in role {}'.format(highlight(target_role.name),
highlight(subject.name)))
include = {'role': target_role.name}
put(api.role(target_role.group.name, subject.name),
data=json.dumps(include))
def principal_exists(principal_name, principal_type):
if principal_type == PrincipalType.USER:
return user_exists(principal_name)
elif principal_type == PrincipalType.ROLE:
return role_exists(principal_name)
else:
raise McmdError('Unknown principal type: %s' % principal_type)
def _do_script_function(line: str):
line_parts = line.strip('$').split()
function = line_parts[0]
if function == 'wait':
_wait(' '.join(line_parts[1:]).strip())
else:
raise McmdError("Unknown function '{}' ".format(function))
def _read_script(script):
try:
with open(script) as file:
lines = [line.rstrip('\n') for line in file]
except OSError as e:
raise McmdError('Error reading script: {}'.format(str(e)))
return lines
def _block_nested_scripts(command: str):
if command == 'run':
raise McmdError(
'Nesting scripts is not supported',
info='If you think it should be, feel free to submit a '
'feature request at '
'https://github.com/molgenis/molgenis-tools'
'-commander/issues!')
def test_mcmd_script_error_wrapped():
try:
error = McmdError("test message", info="don't use it like that")
raise ScriptError.from_error(error, line=3)
except ScriptError as e:
assert e.message == "test message"
assert e.info is "don't use it like that"
assert e.line == 3
def raise_if_non_interactive(message: str):
if config.is_loaded() and config.get('settings', 'non_interactive'):
raise McmdError(
'User input required but running in non-interactive mode. Message: {}'
.format(message),
info=
"Please specify your command more precisely or switch to interactive mode with 'mcmd "
"config set interactive'")
def handle_request(*args, **kwargs):
auth.check_token()
response = str()
try:
response = func(*args, **kwargs)
response.raise_for_status()
return response
except requests.HTTPError as e:
if _is_json(response):
_handle_json_error(response.json())
else:
raise McmdError(str(e))
except requests.exceptions.ConnectionError:
raise MolgenisOfflineError()
except requests.RequestException as e:
raise McmdError(str(e))
def _remove_script(script_name):
path = context().get_scripts_folder().joinpath(script_name)
_check_script_exists(path)
try:
io.start('Removing script %s' % highlight(script_name))
path.unlink()
except OSError as e:
raise McmdError('Error removing script: %s' % str(e))
def _get_script(args):
if args.from_path:
script = Path(args.script)
else:
script = context().get_scripts_folder().joinpath(args.script)
if not script.exists():
raise McmdError("The script {} doesn't exist".format(script))
return script
def test_ping_offline(get_version_mock, capsys):
get_version_mock.side_effect = McmdError('')
run_commander('ping')
captured = capsys.readouterr().out
assert 'Offline' in captured
assert 'Version' not in captured
assert get_host()['url'] in captured
assert get_host()['username'] in captured
def _read_script(script_name):
path = context().get_scripts_folder().joinpath(script_name)
_check_script_exists(path)
try:
with path.open() as f:
for line in f.readlines():
log.info(line.strip())
except OSError as e:
raise McmdError('Error reading script: %s' % str(e))
def load():
try:
if context().get_storage_file().exists():
with context().get_storage_file().open('rb') as f:
_store.update(pickle.load(f))
else:
_persist()
except (pickle.PickleError, IOError) as e:
raise McmdError("Unable to read storage from file: {}".format(
e.message))
def _get_group_id(group_name) -> str:
groups = get(api.rest2('sys_sec_Group'),
params={
'attrs': 'id',
'q': 'name=={}'.format(group_name)
}).json()['items']
if len(groups) == 0:
raise McmdError('No group found with name {}'.format(groups))
else:
return groups[0]['id']
def wrapper(*args, **kwargs):
mol_version = molgenis_version.get_version_number()
if py_version.parse(mol_version) >= py_version.parse(since):
message = '{} is deprecated since MOLGENIS {}. ' \
'You are using MOLGENIS {}.'.format(action.capitalize(),
since,
molgenis_version.get_version())
raise McmdError(message, info=info)
else:
return func(*args, **kwargs)
def _get_subject_type(args) -> PrincipalType:
"""
Prior to 8.1 roles can't be included with the identities API so the subject is always a user.
"""
if args.role:
raise McmdError(
"Including group roles is only possible in MOLGENIS 8.3 and up (you are using {})"
.format(get_version()))
else:
return PrincipalType.USER
def get_attachments(issue_num):
validate_issue_number(issue_num)
try:
issue = _molgenis_repo().get_issue(int(issue_num))
except UnknownObjectException:
raise McmdError("Issue #%s doesn't exist" % issue_num)
# GitHub has no API for downloading attachments so we get them from the issue description
urls = _parse_attachment_urls(issue.body)
return [Attachment(url.strip('()')) for url in urls]
def write(arg_string, success):
try:
history = open(str(context().get_history_file()), 'a')
indicator = _INDICATOR_SUCCESS
if not success:
indicator = _INDICATOR_FAILURE
history.write('%s %s\n' % (indicator, arg_string))
except OSError as e:
raise McmdError("Error writing to history: %s" % str(e))
def _get_role(role_name: str) -> Role:
roles = get(api.rest2('sys_sec_Role'),
params={
'attrs': 'id,name,label,group(id,name)',
'q': 'name=={}'.format(role_name)
}).json()['items']
if len(roles) == 0:
raise McmdError('No role found with name {}'.format(role_name))
else:
return map_to_role(roles[0])
def _get_user(user_name: str) -> User:
users = get(api.rest2('sys_sec_User'),
params={
'attrs': 'id,username',
'q': 'username=={}'.format(user_name)
}).json()['items']
if len(users) == 0:
raise McmdError('Unknown user {}'.format(user_name))
else:
return map_to_user(users[0])
def _get_group_roles(group: Group) -> List[Role]:
roles = get(api.rest2('sys_sec_Role'),
params={
'attrs': 'id,name,label,group(id,name)',
'q': 'group=={}'.format(group.id)
}).json()['items']
if len(roles) == 0:
raise McmdError('No roles found for group {}'.format(group.name))
return [map_to_role(role) for role in roles]
def _select_attachment(issue_num, wanted_attachment):
"""Gets attachments from a GitHub issue. If wanted_attachment is specified it will try to select that attachment."""
attachments = github.get_attachments(issue_num)
if len(attachments) == 0:
raise McmdError("Issue #%s doesn't contain any files" % issue_num)
if wanted_attachment:
selected = [a for a in attachments if a.name == wanted_attachment]
if len(selected) == 0:
raise McmdError('There are no attachments named %s.' %
wanted_attachment)
if len(selected) > 1:
raise McmdError('Multiple attachments with name %s found.' %
wanted_attachment)
return selected[0]
else:
if len(attachments) > 1:
return _choose_attachment(attachments)
else:
return attachments[0]
def _validate_required_args(lines: List[ParsedLine], args: dict):
missing_args = list()
for line in lines:
statement = line.statement
if isinstance(
statement, Value
) and statement.value is None and statement.name not in args:
missing_args.append(statement.name)
if len(missing_args) > 0:
raise McmdError('Missing required argument(s): {}'.format(
', '.join(missing_args)))
def read_file(file: Path) -> str:
"""
read_file reads the file data into a string
:param file: file to read from
:return: file contents
"""
try:
with file.open() as file_handle:
content = file_handle.read()
except OSError as e:
raise McmdError('Error reading file: {}'.format(str(e)))
return content
def read_file_lines(file: Path) -> List[str]:
"""
read_file reads the file data into a list of strings
:param file: file to read from
:return: list of lines
"""
try:
with file.open() as file_handle:
content = file_handle.read().splitlines()
except OSError as e:
raise McmdError('Error reading file: {}'.format(str(e)))
return content
def _get_version():
try:
response = requests.get(urljoin(config.get('host', 'selected'), 'api/v2/version'),
headers={'Content-Type': 'application/json'})
response.raise_for_status()
global _version
global _version_number
_version = response.json()['molgenisVersion']
_version_number = _extract_version_number(_version)
except HTTPError as e:
raise McmdError(str(e))
except requests.exceptions.ConnectionError:
raise MolgenisOfflineError()
def _create_script(args):
lines = history.read(args.number, args.show_fails)
if len(lines) == 0:
log.info('History is empty.')
return
options = [line[1] for line in lines]
commands = mcmd.io.ask.checkbox('Pick the lines that will form the script:', options)
file_name = _input_script_name()
try:
with open(str(context().get_scripts_folder().joinpath(file_name)), 'w') as script_file:
for cmd in commands:
script_file.write(cmd + '\n')
except OSError as e:
raise McmdError("Error writing to script: %s" % str(e))
def _run_command(command: Command, state: _ScriptExecutionState):
cmd = command.command.render(state.values)
try:
sub_args = arg_parser.parse_args(shlex.split(cmd))
except ArgumentSyntaxError as e:
raise McmdError(message=str(e))
_block_nested_scripts(sub_args.command)
if state.options.dry_run:
log.info(cmd)
else:
setattr(sub_args, 'arg_string', cmd)
sub_args.func(sub_args, nested=True)
