def role_list(endpoint_id):
"""
List the assigned roles on an endpoint.
You must have sufficient privileges to see the roles on the endpoint.
"""
client = get_client()
roles = client.endpoint_role_list(endpoint_id)
resolved_ids = IdentityMap(
get_auth_client(),
(x["principal"] for x in roles if x["principal_type"] == "identity"),
)
def principal_str(role):
principal = role["principal"]
if role["principal_type"] == "identity":
try:
return resolved_ids[principal]["username"]
except KeyError:
return principal
if role["principal_type"] == "group":
return (u"https://app.globus.org/groups/{}").format(principal)
return principal
formatted_print(
roles,
fields=[
("Principal Type", "principal_type"),
("Role ID", "id"),
("Principal", principal_str),
("Role", "role"),
],
)
def server_add(
endpoint_id,
subject,
port,
scheme,
hostname,
incoming_data_ports,
outgoing_data_ports,
):
"""
Executor for `globus endpoint server add`
"""
client = get_client()
server_doc = assemble_generic_doc("server",
subject=subject,
port=port,
scheme=scheme,
hostname=hostname)
# n.b. must be done after assemble_generic_doc(), as that function filters
# out `None`s, which we need to be able to set for `'unspecified'`
if incoming_data_ports:
server_doc.update(
incoming_data_port_start=incoming_data_ports[0],
incoming_data_port_end=incoming_data_ports[1],
)
if outgoing_data_ports:
server_doc.update(
outgoing_data_port_start=outgoing_data_ports[0],
outgoing_data_port_end=outgoing_data_ports[1],
)
res = client.add_endpoint_server(endpoint_id, server_doc)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def role_list(endpoint_id):
"""
Executor for `globus access endpoint-role-list`
"""
client = get_client()
roles = client.endpoint_role_list(endpoint_id)
resolved_ids = LazyIdentityMap(
x["principal"] for x in roles if x["principal_type"] == "identity"
)
def principal_str(role):
principal = role["principal"]
if role["principal_type"] == "identity":
username = resolved_ids.get(principal)
return username or principal
elif role["principal_type"] == "group":
return (u"https://app.globus.org/groups/{}").format(principal)
else:
return principal
formatted_print(
roles,
fields=[
("Principal Type", "principal_type"),
("Role ID", "id"),
("Principal", principal_str),
("Role", "role"),
],
)
def rename_command(source, destination):
"""Rename a file or directory on an endpoint.
The old path must be an existing file or directory. The new path must not yet
exist.
The new path does not have to be in the same directory as the old path, but
most endpoints will require it to stay on the same filesystem.
The endpoint must be entered twice for the sake of path syntax consistency.
"""
source_ep, source_path = source
dest_ep, dest_path = destination
if source_ep != dest_ep:
raise click.UsageError(
("rename requires that the source and dest "
"endpoints are the same, {} != {}").format(source_ep, dest_ep))
endpoint_id = source_ep
client = get_client()
autoactivate(client, endpoint_id, if_expires_in=60)
res = client.operation_rename(endpoint_id,
oldpath=source_path,
newpath=dest_path)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def bookmark_list():
"""
Executor for `globus bookmark list`
"""
client = get_client()
bookmark_iterator = client.bookmark_list()
def get_ep_name(item):
ep_id = item['endpoint_id']
try:
ep_doc = client.get_endpoint(ep_id)
return display_name_or_cname(ep_doc)
except TransferAPIError as err:
if err.code == "EndpointDeleted":
return "[DELETED ENDPOINT]"
else:
raise err
formatted_print(bookmark_iterator,
fields=[('Name', 'name'), ('Bookmark ID', 'id'),
('Endpoint ID', 'endpoint_id'),
('Endpoint Name', get_ep_name), ('Path', 'path')],
response_key='DATA',
json_converter=iterable_response_to_dict)
def list_command(endpoint_id):
"""
Executor for `globus endpoint permission list`
"""
client = get_client()
rules = client.endpoint_acl_list(endpoint_id)
resolved_ids = LazyIdentityMap(
x["principal"] for x in rules if x["principal_type"] == "identity"
)
def principal_str(rule):
principal = rule["principal"]
if rule["principal_type"] == "identity":
username = resolved_ids.get(principal)
return username or principal
elif rule["principal_type"] == "group":
return (u"https://app.globus.org/groups/{}").format(principal)
else:
principal = rule["principal_type"]
return principal
formatted_print(
rules,
fields=[
("Rule ID", "id"),
("Permissions", "permissions"),
("Shared With", principal_str),
("Path", "path"),
],
)
def check_completed():
completed = client.task_wait(
task_id, timeout=polling_interval, polling_interval=polling_interval
)
if completed:
if heartbeat:
safeprint("", write_to_stderr=True)
# meowing tasks wake up!
if meow:
safeprint(
r"""
_..
/}_{\ /.-'
( a a )-.___...-'/
==._.== ;
\ i _..._ /,
{_;/ {_//""",
write_to_stderr=True,
)
# TODO: possibly update TransferClient.task_wait so that we don't
# need to do an extra fetch to get the task status after completion
res = client.get_task(task_id)
formatted_print(res, text_format=FORMAT_SILENT)
status = res["status"]
if status == "SUCCEEDED":
click.get_current_context().exit(0)
else:
click.get_current_context().exit(1)
return completed
def role_create(role, principal, endpoint_id):
"""
Executor for `globus endpoint role show`
"""
principal_type, principal_val = principal
client = get_client()
if principal_type == "identity":
principal_val = maybe_lookup_identity_id(principal_val)
if not principal_val:
raise click.UsageError(
"Identity does not exist. "
"Use --provision-identity to auto-provision an identity."
)
elif principal_type == "provision-identity":
principal_val = maybe_lookup_identity_id(principal_val, provision=True)
principal_type = "identity"
role_doc = assemble_generic_doc(
"role", principal_type=principal_type, principal=principal_val, role=role
)
res = client.add_endpoint_role(endpoint_id, role_doc)
formatted_print(res, simple_text="ID: {}".format(res["id"]))
def endpoint_show(endpoint_id):
"""
Executor for `globus endpoint show`
"""
client = get_client()
res = client.get_endpoint(endpoint_id)
def _managed_endpoint(x):
""" Helper for converting subscription_id into managed_endpoint """
return bool(x["subscription_id"])
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=(("Display Name", "display_name"), ("ID", "id"),
("Owner", "owner_string"), ("Activated", "activated"),
("Shareable", "shareable"), ("Department", "department"),
("Keywords", "keywords"), ("Endpoint Info Link",
"info_link"), ("Contact E-mail",
"contact_email"),
("Organization", "organization"), ("Department", "department"),
("Other Contact Info",
"contact_info"), ("Visibility",
"public"), ("Default Directory",
"default_directory"),
("Force Encryption", "force_encryption"), ("Managed Endpoint",
_managed_endpoint),
("Subscription ID", "subscription_id"), ("Legacy Name",
"canonical_name"),
("Local User Info Available", "local_user_info_available")))
def role_delete(role_id, endpoint_id):
"""
Executor for `globus endpoint role delete`
"""
client = get_client()
res = client.delete_endpoint_role(endpoint_id, role_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def role_create(role, principal, endpoint_id):
"""
Executor for `globus endpoint role show`
"""
principal_type, principal_val = principal
client = get_client()
if principal_type == 'identity':
principal_val = maybe_lookup_identity_id(principal_val)
if not principal_val:
raise click.UsageError(
'Identity does not exist. '
'Use --provision-identity to auto-provision an identity.')
elif principal_type == 'provision-identity':
principal_val = maybe_lookup_identity_id(principal_val, provision=True)
principal_type = 'identity'
role_doc = assemble_generic_doc('role',
principal_type=principal_type,
principal=principal_val,
role=role)
res = client.add_endpoint_role(endpoint_id, role_doc)
formatted_print(res, simple_text='ID: {}'.format(res['id']))
def role_delete(role_id, endpoint_id):
"""
Executor for `globus endpoint role delete`
"""
client = get_client()
res = client.delete_endpoint_role(endpoint_id, role_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key='message')
def print_successful_transfers(client, task_id):
res = client.task_successful_transfers(task_id, num_results=None)
formatted_print(
res,
fields=SUCCESSFULL_TRANSFER_FIELDS,
json_converter=iterable_response_to_dict,
)
def endpoint_delete(endpoint_id):
"""
Executor for `globus endpoint delete`
"""
client = get_client()
res = client.delete_endpoint(endpoint_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def list_command(endpoint_id):
"""List all rules in an endpoint's access control list."""
client = get_client()
rules = client.endpoint_acl_list(endpoint_id)
resolved_ids = IdentityMap(
get_auth_client(),
(x["principal"] for x in rules if x["principal_type"] == "identity"),
)
def principal_str(rule):
principal = rule["principal"]
if rule["principal_type"] == "identity":
try:
return resolved_ids[principal]["username"]
except KeyError:
return principal
if rule["principal_type"] == "group":
return (u"https://app.globus.org/groups/{}").format(principal)
return rule["principal_type"]
formatted_print(
rules,
fields=[
("Rule ID", "id"),
("Permissions", "permissions"),
("Shared With", principal_str),
("Path", "path"),
],
)
def role_create(role, principal, endpoint_id):
"""
Create a role on an endpoint.
You must have sufficient privileges to modify the roles on the endpoint.
Either *--group* or *--identity* is required. You may not pass both.
Which one of these options you use will determine the 'Principal Type' on the
role, and the value given will be the 'Principal' of the resulting role.
The term "Principal" is used in the sense of "a security principal", an entity
which has some privileges associated with it.
"""
principal_type, principal_val = principal
client = get_client()
if principal_type == "identity":
principal_val = maybe_lookup_identity_id(principal_val)
if not principal_val:
raise click.UsageError(
"Identity does not exist. "
"Use --provision-identity to auto-provision an identity.")
elif principal_type == "provision-identity":
principal_val = maybe_lookup_identity_id(principal_val, provision=True)
principal_type = "identity"
role_doc = assemble_generic_doc("role",
principal_type=principal_type,
principal=principal_val,
role=role)
res = client.add_endpoint_role(endpoint_id, role_doc)
formatted_print(res, simple_text="ID: {}".format(res["id"]))
def endpoint_update(**kwargs):
"""
Executor for `globus endpoint update`
"""
# validate params. Requires a get call to check the endpoint type
client = get_client()
endpoint_id = kwargs.pop("endpoint_id")
get_res = client.get_endpoint(endpoint_id)
if get_res["host_endpoint_id"]:
endpoint_type = "shared"
elif get_res["is_globus_connect"]:
endpoint_type = "personal"
elif get_res["s3_url"]:
endpoint_type = "s3"
else:
endpoint_type = "server"
validate_endpoint_create_and_update_params(
endpoint_type, get_res["subscription_id"], kwargs
)
# make the update
ep_doc = assemble_generic_doc("endpoint", **kwargs)
res = client.update_endpoint(endpoint_id, ep_doc)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def list_command(endpoint_id):
"""
Executor for `globus endpoint permission list`
"""
client = get_client()
rules = client.endpoint_acl_list(endpoint_id)
resolved_ids = LazyIdentityMap(x['principal'] for x in rules
if x['principal_type'] == 'identity')
def principal_str(rule):
principal = rule['principal']
if rule['principal_type'] == 'identity':
username = resolved_ids.get(principal)
return username or principal
elif rule['principal_type'] == 'group':
return (u'https://www.globus.org/app/groups/{}').format(principal)
else:
principal = rule['principal_type']
return principal
formatted_print(rules,
fields=[('Rule ID', 'id'), ('Permissions', 'permissions'),
('Shared With', principal_str), ('Path', 'path')])
def endpoint_update(**kwargs):
"""
Executor for `globus endpoint update`
"""
# validate params. Requires a get call to check the endpoint type
client = get_client()
endpoint_id = kwargs.pop("endpoint_id")
get_res = client.get_endpoint(endpoint_id)
if get_res["host_endpoint_id"]:
endpoint_type = "shared"
elif get_res["is_globus_connect"]:
endpoint_type = "personal"
elif get_res["s3_url"]:
endpoint_type = "s3"
else:
endpoint_type = "server"
validate_endpoint_create_and_update_params(endpoint_type,
get_res["subscription_id"],
kwargs)
# make the update
ep_doc = assemble_generic_doc('endpoint', **kwargs)
res = client.update_endpoint(endpoint_id, ep_doc)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key='message')
def server_show(endpoint_id, server_id):
"""
Executor for `globus endpoint server show`
"""
client = get_client()
server_doc = client.get_endpoint_server(endpoint_id, server_id)
if not server_doc['uri']: # GCP endpoint server
fields = (('ID', 'id'),)
text_epilog = dedent("""
This server is for a Globus Connect Personal installation.
For its connection status, try:
globus endpoint show {}
""".format(endpoint_id))
else:
def advertised_port_summary(server):
def get_range_summary(start, end):
return ('unspecified' if not start and not end
else 'unrestricted' if start == 1024 and end == 65535
else '{}-{}'.format(start, end))
return "incoming {}, outgoing {}".format(
get_range_summary(server['incoming_data_port_start'],
server['incoming_data_port_end']),
get_range_summary(server['outgoing_data_port_start'],
server['outgoing_data_port_end']),
)
fields = (('ID', 'id'), ('URI', 'uri'), ('Subject', 'subject'),
('Data Ports', advertised_port_summary))
text_epilog = None
formatted_print(server_doc, text_format=FORMAT_TEXT_RECORD,
fields=fields, text_epilog=text_epilog)
def task_pause_info(task_id):
"""
Executor for `globus task pause-info`
"""
client = get_client()
res = client.task_pause_info(task_id)
def _custom_text_format(res):
explicit_pauses = [
field for field in EXPLICIT_PAUSE_MSG_FIELDS
# n.b. some keys are absent for completed tasks
if res.get(field[1])
]
effective_pause_rules = res['pause_rules']
if not explicit_pauses and not effective_pause_rules:
safeprint('Task {} is not paused.'.format(task_id))
click.get_current_context().exit(0)
if explicit_pauses:
formatted_print(
res, fields=explicit_pauses, text_format=FORMAT_TEXT_RECORD,
text_preamble='This task has been explicitly paused.\n',
text_epilog='\n' if effective_pause_rules else None)
if effective_pause_rules:
formatted_print(
effective_pause_rules, fields=PAUSE_RULE_DISPLAY_FIELDS,
text_preamble=(
'The following pause rules are effective on this task:\n'))
formatted_print(res, text_format=_custom_text_format)
def check_completed():
completed = client.task_wait(task_id,
timeout=polling_interval,
polling_interval=polling_interval)
if completed:
if heartbeat:
safeprint('', write_to_stderr=True)
# meowing tasks wake up!
if meow:
safeprint(r"""
_..
/}_{\ /.-'
( a a )-.___...-'/
==._.== ;
\ i _..._ /,
{_;/ {_//""",
write_to_stderr=True)
# TODO: possibly update TransferClient.task_wait so that we don't
# need to do an extra fetch to get the task status after completion
res = client.get_task(task_id)
formatted_print(res, text_format=FORMAT_SILENT)
status = res['status']
if status == 'SUCCEEDED':
click.get_current_context().exit(0)
else:
click.get_current_context().exit(1)
return completed
def bookmark_create(endpoint_plus_path, bookmark_name):
"""
Create a new bookmark. Given an endpoint plus a path, and a name for the bookmark,
the service will generate the bookmark's ID.
Bookmarks are aliases for locations on endpoints, and their names are unique
per account. You may not have multiple bookmarks with the same name. You can
use bookmarks in other commands by using *globus bookmark show*.
The new bookmark name may be up to 128 characters long.
Bookmarks are only visible and usable for the user who created them. If the
target endpoint is private or deleted, the bookmark is unusable.
'PATH' is assumed to be URL-encoded. 'PATH' must be a directory and end with "/".
"""
endpoint_id, path = endpoint_plus_path
client = get_client()
submit_data = {
"endpoint_id": str(endpoint_id),
"path": path,
"name": bookmark_name
}
res = client.create_bookmark(submit_data)
formatted_print(res, simple_text="Bookmark ID: {}".format(res["id"]))
def list_command(endpoint_id):
"""
Executor for `globus endpoint permission list`
"""
client = get_client()
rules = client.endpoint_acl_list(endpoint_id)
resolved_ids = LazyIdentityMap(x["principal"] for x in rules
if x["principal_type"] == "identity")
def principal_str(rule):
principal = rule["principal"]
if rule["principal_type"] == "identity":
username = resolved_ids.get(principal)
return username or principal
elif rule["principal_type"] == "group":
return (u"https://app.globus.org/groups/{}").format(principal)
else:
principal = rule["principal_type"]
return principal
formatted_print(
rules,
fields=[
("Rule ID", "id"),
("Permissions", "permissions"),
("Shared With", principal_str),
("Path", "path"),
],
)
def print_successful_transfers(client, task_id):
res = client.task_successful_transfers(task_id, num_results=None)
formatted_print(
res,
fields=SUCCESSFULL_TRANSFER_FIELDS,
json_converter=iterable_response_to_dict,
)
def server_update(
endpoint_id,
server_id,
subject,
port,
scheme,
hostname,
incoming_data_ports,
outgoing_data_ports,
):
"""
Executor for `globus endpoint server update`
"""
client = get_client()
server_doc = assemble_generic_doc(
"server", subject=subject, port=port, scheme=scheme, hostname=hostname
)
# n.b. must be done after assemble_generic_doc(), as that function filters
# out `None`s, which we need to be able to set for `'unspecified'`
if incoming_data_ports:
server_doc.update(
incoming_data_port_start=incoming_data_ports[0],
incoming_data_port_end=incoming_data_ports[1],
)
if outgoing_data_ports:
server_doc.update(
outgoing_data_port_start=outgoing_data_ports[0],
outgoing_data_port_end=outgoing_data_ports[1],
)
res = client.update_endpoint_server(endpoint_id, server_id, server_doc)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def bookmark_show(bookmark_id_or_name):
"""
Given a single bookmark ID or bookmark name, show the bookmark details. By default,
when the format is TEXT, this will display the endpoint ID and path in
'ENDPOINT_ID:PATH' notation.
The default output is suitable for use in a subshell in another command.
If *-v, --verbose* is given, several fields will be displayed.
"""
client = get_client()
res = resolve_id_or_name(client, bookmark_id_or_name)
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=(
("ID", "id"),
("Name", "name"),
("Endpoint ID", "endpoint_id"),
("Path", "path"),
),
simple_text=(
# standard output is endpoint:path format
"{}:{}".format(res["endpoint_id"], res["path"])
# verbose output includes all fields
if not is_verbose() else None),
)
def server_show(endpoint_id, server_id):
"""
Executor for `globus endpoint server show`
"""
client = get_client()
server_doc = client.get_endpoint_server(endpoint_id, server_id)
if not server_doc['uri']: # GCP endpoint server
fields = (('ID', 'id'), ('Is Connected', 'is_connected'),
('Is Paused (macOS only)', 'is_paused'))
else:
def advertised_port_summary(server):
def get_range_summary(start, end):
return ('unspecified' if not start and not end
else 'unrestricted' if start == 1024 and end == 65535
else '{}-{}'.format(start, end))
return "incoming {}, outgoing {}".format(
get_range_summary(server['incoming_data_port_start'],
server['incoming_data_port_end']),
get_range_summary(server['outgoing_data_port_start'],
server['outgoing_data_port_end']),
)
fields = (('ID', 'id'), ('URI', 'uri'), ('Subject', 'subject'),
('Data Ports', advertised_port_summary))
formatted_print(server_doc, text_format=FORMAT_TEXT_RECORD,
fields=fields)
def _custom_text_format(res):
explicit_pauses = [
field
for field in EXPLICIT_PAUSE_MSG_FIELDS
# n.b. some keys are absent for completed tasks
if res.get(field[1])
]
effective_pause_rules = res["pause_rules"]
if not explicit_pauses and not effective_pause_rules:
click.echo("Task {} is not paused.".format(task_id))
click.get_current_context().exit(0)
if explicit_pauses:
formatted_print(
res,
fields=explicit_pauses,
text_format=FORMAT_TEXT_RECORD,
text_preamble="This task has been explicitly paused.\n",
text_epilog="\n" if effective_pause_rules else None,
)
if effective_pause_rules:
formatted_print(
effective_pause_rules,
fields=PAUSE_RULE_DISPLAY_FIELDS,
text_preamble=(
"The following pause rules are effective on this task:\n"
),
)
def endpoint_deactivate(endpoint_id):
"""
Executor for `globus endpoint deactivate`
"""
client = get_client()
res = client.endpoint_deactivate(endpoint_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def bookmark_list():
"""
Executor for `globus bookmark list`
"""
client = get_client()
bookmark_iterator = client.bookmark_list()
def get_ep_name(item):
ep_id = item["endpoint_id"]
try:
ep_doc = client.get_endpoint(ep_id)
return display_name_or_cname(ep_doc)
except TransferAPIError as err:
if err.code == "EndpointDeleted":
return "[DELETED ENDPOINT]"
else:
raise err
formatted_print(
bookmark_iterator,
fields=[
("Name", "name"),
("Bookmark ID", "id"),
("Endpoint ID", "endpoint_id"),
("Endpoint Name", get_ep_name),
("Path", "path"),
],
response_key="DATA",
json_converter=iterable_response_to_dict,
)
def endpoint_search(filter_fulltext, filter_owner_id, filter_scope):
"""
Executor for `globus endpoint search`
"""
if filter_scope == "all" and not filter_fulltext:
raise click.UsageError(
"When searching all endpoints (--filter-scope=all, the default), "
"a full-text search filter is required. Other scopes (e.g. "
"--filter-scope=recently-used) may be used without specifying "
"an additional filter."
)
client = get_client()
owner_id = filter_owner_id
if owner_id:
owner_id = maybe_lookup_identity_id(owner_id)
search_iterator = client.endpoint_search(
filter_fulltext=filter_fulltext,
filter_scope=filter_scope,
filter_owner_id=owner_id,
)
formatted_print(
search_iterator,
fields=ENDPOINT_LIST_FIELDS,
json_converter=iterable_response_to_dict,
)
def whoami_command(linked_identities):
"""
Executor for `globus whoami`
"""
client = get_auth_client()
# get userinfo from auth.
# if we get back an error the user likely needs to log in again
try:
res = client.oauth2_userinfo()
except AuthAPIError:
safeprint(
"Unable to get user information. Please try " "logging in again.",
write_to_stderr=True,
)
click.get_current_context().exit(1)
print_command_hint(
"For information on which identities are in session see\n"
" globus session show\n"
)
# --linked-identities either displays all usernames or a table if verbose
if linked_identities:
try:
formatted_print(
res["identity_set"],
fields=[
("Username", "username"),
("Name", "name"),
("ID", "sub"),
("Email", "email"),
],
simple_text=(
None
if is_verbose()
else "\n".join([x["username"] for x in res["identity_set"]])
),
)
except KeyError:
safeprint(
"Your current login does not have the consents required "
"to view your full identity set. Please log in again "
"to agree to the required consents.",
write_to_stderr=True,
)
# Default output is the top level data
else:
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=[
("Username", "preferred_username"),
("Name", "name"),
("ID", "sub"),
("Email", "email"),
],
simple_text=(None if is_verbose() else res["preferred_username"]),
)
def get_identities_command(values):
"""
Executor for `globus get-identities`
"""
client = get_auth_client()
resolved_values = [_try_b32_decode(v) or v for v in values]
# since API doesn't accept mixed ids and usernames,
# split input values into separate lists
ids = []
usernames = []
for val in resolved_values:
try:
uuid.UUID(val)
ids.append(val)
except ValueError:
usernames.append(val)
# make two calls to get_identities with ids and usernames
# then combine the calls into one response
results = []
if len(ids):
results += client.get_identities(ids=ids)["identities"]
if len(usernames):
results += client.get_identities(usernames=usernames)["identities"]
res = GlobusResponse({"identities": results})
def _custom_text_format(identities):
"""
Non-verbose text output is customized
"""
def resolve_identity(value):
"""
helper to deal with variable inputs and uncertain response order
"""
for identity in identities:
if identity["id"] == value:
return identity["username"]
if identity["username"] == value:
return identity["id"]
return "NO_SUCH_IDENTITY"
# standard output is one resolved identity per line in the same order
# as the inputs. A resolved identity is either a username if given a
# UUID vice versa, or "NO_SUCH_IDENTITY" if the identity could not be
# found
for val in resolved_values:
safeprint(resolve_identity(val))
formatted_print(
res,
response_key='identities',
fields=[('ID', 'id'), ('Username', 'username'), ('Full Name', 'name'),
('Organization', 'organization'), ('Email Address', 'email')],
# verbose output is a table. Order not guaranteed, may contain
# duplicates
text_format=(FORMAT_TEXT_TABLE
if is_verbose() else _custom_text_format))
def rm_command(ignore_missing, star_silent, recursive, enable_globs,
endpoint_plus_path, label, submission_id, dry_run, deadline,
skip_activation_check, notify, meow, heartbeat,
polling_interval, timeout):
"""
Executor for `globus rm`
"""
endpoint_id, path = endpoint_plus_path
client = get_client()
# attempt to activate unless --skip-activation-check is given
if not skip_activation_check:
autoactivate(client, endpoint_id, if_expires_in=60)
delete_data = DeleteData(client,
endpoint_id,
label=label,
recursive=recursive,
ignore_missing=ignore_missing,
submission_id=submission_id,
deadline=deadline,
skip_activation_check=skip_activation_check,
interpret_globs=enable_globs,
**notify)
if not star_silent and enable_globs and path.endswith('*'):
# not intuitive, but `click.confirm(abort=True)` prints to stdout
# unnecessarily, which we don't really want...
# only do this check if stderr is a pty
if (err_is_terminal() and term_is_interactive() and not click.confirm(
'Are you sure you want to delete all files matching "{}"?'.
format(path),
err=True)):
safeprint('Aborted.', write_to_stderr=True)
click.get_current_context().exit(1)
delete_data.add_item(path)
if dry_run:
formatted_print(delete_data,
response_key='DATA',
fields=[('Path', 'path')])
# exit safely
return
# Print task submission to stderr so that `-Fjson` is still correctly
# respected, as it will be by `task wait`
res = client.submit_delete(delete_data)
task_id = res['task_id']
safeprint('Delete task submitted under ID "{}"'.format(task_id),
write_to_stderr=True)
# do a `task wait` equivalent, including printing and correct exit status
task_wait_with_io(meow,
heartbeat,
polling_interval,
timeout,
task_id,
client=client)
def generate_submission_id():
"""
Executor for `globus task generate-submission-id`
"""
client = get_client()
res = client.get_submission_id()
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="value")
def endpoint_deactivate(endpoint_id):
"""
Remove the credential previously assigned to an endpoint via
'globus endpoint activate' or any other form of endpoint activation
"""
client = get_client()
res = client.endpoint_deactivate(endpoint_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def generate_submission_id():
"""
Executor for `globus task generate-submission-id`
"""
client = get_client()
res = client.get_submission_id()
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="value")
def my_shared_endpoint_list(endpoint_id):
"""
Executor for `globus endpoint my-shared-endpoint-list`
"""
client = get_client()
ep_iterator = client.my_shared_endpoint_list(endpoint_id)
formatted_print(ep_iterator, fields=ENDPOINT_LIST_FIELDS)
def delete_command(endpoint_id, rule_id):
"""
Executor for `globus endpoint permission delete`
"""
client = get_client()
res = client.delete_endpoint_acl_rule(endpoint_id, rule_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def delete_command(endpoint_id, rule_id):
"""
Executor for `globus endpoint permission delete`
"""
client = get_client()
res = client.delete_endpoint_acl_rule(endpoint_id, rule_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key='message')
def my_shared_endpoint_list(endpoint_id):
"""
Executor for `globus endpoint my-shared-endpoint-list`
"""
client = get_client()
ep_iterator = client.my_shared_endpoint_list(endpoint_id)
formatted_print(ep_iterator, fields=ENDPOINT_LIST_FIELDS)
def bookmark_delete(bookmark_id_or_name):
"""
Executor for `globus bookmark delete`
"""
client = get_client()
bookmark_id = resolve_id_or_name(client, bookmark_id_or_name)["id"]
res = client.delete_bookmark(bookmark_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def role_delete(role_id, endpoint_id):
"""
Remove a role from an endpoint.
You must have sufficient privileges to modify the roles on the endpoint.
"""
client = get_client()
res = client.delete_endpoint_role(endpoint_id, role_id)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def update_command(permissions, rule_id, endpoint_id):
"""
Executor for `globus endpoint permission update`
"""
client = get_client()
rule_data = assemble_generic_doc("access", permissions=permissions)
res = client.update_endpoint_acl_rule(endpoint_id, rule_id, rule_data)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def fail(deadline=None):
exp_string = ""
if deadline is not None:
exp_string = " or will expire within {} seconds".format(deadline)
message = "The endpoint is not activated{}.\n\n".format(
exp_string
) + activation_requirements_help_text(res, endpoint_id)
formatted_print(res, simple_text=message)
click.get_current_context().exit(1)
def update_task(deadline, label, task_id):
"""
Executor for `globus task update`
"""
client = get_client()
task_doc = assemble_generic_doc("task", label=label, deadline=deadline)
res = client.update_task(task_id, task_doc)
formatted_print(res, simple_text="Success")
def bookmark_rename(bookmark_id_or_name, new_bookmark_name):
"""
Executor for `globus bookmark rename`
"""
client = get_client()
bookmark_id = resolve_id_or_name(client, bookmark_id_or_name)["id"]
submit_data = {"name": new_bookmark_name}
res = client.update_bookmark(bookmark_id, submit_data)
formatted_print(res, simple_text="Success")
def mkdir_command(endpoint_plus_path):
"""
Executor for `globus mkdir`
"""
endpoint_id, path = endpoint_plus_path
client = get_client()
autoactivate(client, endpoint_id, if_expires_in=60)
res = client.operation_mkdir(endpoint_id, path=path)
formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
def print_task_detail(client, task_id):
res = client.get_task(task_id)
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=(
COMMON_FIELDS
+ (COMPLETED_FIELDS if res["completion_time"] else ACTIVE_FIELDS)
+ (DELETE_FIELDS if res["type"] == "DELETE" else TRANSFER_FIELDS)
),
)
def server_show(endpoint_id, server_id):
"""
Executor for `globus endpoint server show`
"""
client = get_client()
server_doc = client.get_endpoint_server(endpoint_id, server_id)
if not server_doc["uri"]: # GCP endpoint server
fields = (("ID", "id"),)
text_epilog = dedent(
"""
This server is for a Globus Connect Personal installation.
For its connection status, try:
globus endpoint show {}
""".format(
endpoint_id
)
)
else:
def advertised_port_summary(server):
def get_range_summary(start, end):
return (
"unspecified"
if not start and not end
else "unrestricted"
if start == 1024 and end == 65535
else "{}-{}".format(start, end)
)
return "incoming {}, outgoing {}".format(
get_range_summary(
server["incoming_data_port_start"], server["incoming_data_port_end"]
),
get_range_summary(
server["outgoing_data_port_start"], server["outgoing_data_port_end"]
),
)
fields = (
("ID", "id"),
("URI", "uri"),
("Subject", "subject"),
("Data Ports", advertised_port_summary),
)
text_epilog = None
formatted_print(
server_doc,
text_format=FORMAT_TEXT_RECORD,
fields=fields,
text_epilog=text_epilog,
)
def bookmark_create(endpoint_plus_path, bookmark_name):
"""
Executor for `globus bookmark create`
"""
endpoint_id, path = endpoint_plus_path
client = get_client()
submit_data = {"endpoint_id": str(endpoint_id), "path": path, "name": bookmark_name}
res = client.create_bookmark(submit_data)
formatted_print(res, simple_text="Bookmark ID: {}".format(res["id"]))
def endpoint_show(endpoint_id):
"""
Executor for `globus endpoint show`
"""
client = get_client()
res = client.get_endpoint(endpoint_id)
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=GCP_FIELDS if res["is_globus_connect"] else STANDARD_FIELDS,
)
def role_show(endpoint_id, role_id):
"""
Executor for `globus endpoint role show`
"""
client = get_client()
role = client.get_endpoint_role(endpoint_id, role_id)
formatted_print(
role,
text_format=FORMAT_TEXT_RECORD,
fields=(
("Principal Type", "principal_type"),
("Principal", lookup_principal),
("Role", "role"),
),
)
def session_show():
# get a token to introspect, refreshing if neccecary
auth_client = internal_auth_client()
try:
auth_client.authorizer._check_expiration_time()
except AttributeError: # if we have no RefreshTokenAuthorizor
pass
access_token = lookup_option(AUTH_AT_OPTNAME)
# only instance clients can introspect tokens
if isinstance(auth_client, globus_sdk.ConfidentialAppAuthClient):
res = auth_client.oauth2_token_introspect(access_token, include="session_info")
session_info = res.get("session_info", {})
authentications = session_info.get("authentications") or {}
# empty session if still using Native App Client
else:
session_info = {}
authentications = {}
# resolve ids to human readable usernames
resolved_ids = LazyIdentityMap(list(authentications))
# put the nested dicts in a format table output can work with
# while also converting vals into human readable formats
list_data = [
{
"id": key,
"username": resolved_ids.get(key),
"auth_time": time.strftime(
"%Y-%m-%d %H:%M %Z", time.localtime(vals["auth_time"])
),
}
for key, vals in authentications.items()
]
print_command_hint(
"For information on your primary identity or full identity set see\n"
" globus whoami\n"
)
formatted_print(
list_data,
json_converter=lambda x: session_info,
fields=[("Username", "username"), ("ID", "id"), ("Auth Time", "auth_time")],
)
def show_command(endpoint_id, rule_id):
"""
Executor for `globus endpoint permission show`
"""
client = get_client()
rule = client.get_endpoint_acl_rule(endpoint_id, rule_id)
formatted_print(
rule,
text_format=FORMAT_TEXT_RECORD,
fields=(
("Rule ID", "id"),
("Permissions", "permissions"),
("Shared With", _shared_with_keyfunc),
("Path", "path"),
),
)
def task_event_list(task_id, limit, filter_errors, filter_non_errors):
"""
Executor for `globus task-event-list`
"""
client = get_client()
# cannot filter by both errors and non errors
if filter_errors and filter_non_errors:
raise click.UsageError("Cannot filter by both errors and non errors")
elif filter_errors:
filter_string = "is_error:1"
elif filter_non_errors:
filter_string = "is_error:0"
else:
filter_string = ""
event_iterator = client.task_event_list(
task_id, num_results=limit, filter=filter_string
)
def squashed_json_details(x):
is_json = False
try:
loaded = json.loads(x["details"])
is_json = True
except ValueError:
loaded = x["details"]
if is_json:
return json.dumps(loaded, separators=(",", ":"), sort_keys=True)
else:
return loaded.replace("\n", "\\n")
formatted_print(
event_iterator,
fields=(
("Time", "time"),
("Code", "code"),
("Is Error", "is_error"),
("Details", squashed_json_details),
),
json_converter=iterable_response_to_dict,
)
def server_list(endpoint_id):
"""
Executor for `globus endpoint server list`
"""
# raises usage error on shares for us
endpoint, server_list = get_endpoint_w_server_list(endpoint_id)
if server_list == "S3": # not GCS -- this is an S3 endpoint
server_list = {"s3_url": endpoint["s3_url"]}
fields = [("S3 URL", "s3_url")]
text_format = FORMAT_TEXT_RECORD
else: # regular GCS host endpoint
fields = (
("ID", "id"),
("URI", lambda s: (s["uri"] or "none (Globus Connect Personal)")),
)
text_format = FORMAT_TEXT_TABLE
formatted_print(server_list, text_format=text_format, fields=fields)
def create_command(
principal, permissions, endpoint_plus_path, notify_email, notify_message
):
"""
Executor for `globus endpoint permission create`
"""
if not principal:
raise click.UsageError("A security principal is required for this command")
endpoint_id, path = endpoint_plus_path
principal_type, principal_val = principal
client = get_client()
if principal_type == "identity":
principal_val = maybe_lookup_identity_id(principal_val)
if not principal_val:
raise click.UsageError(
"Identity does not exist. "
"Use --provision-identity to auto-provision an identity."
)
elif principal_type == "provision-identity":
principal_val = maybe_lookup_identity_id(principal_val, provision=True)
principal_type = "identity"
if not notify_email:
notify_message = None
rule_data = assemble_generic_doc(
"access",
permissions=permissions,
principal=principal_val,
principal_type=principal_type,
path=path,
notify_email=notify_email,
notify_message=notify_message,
)
res = client.add_endpoint_acl_rule(endpoint_id, rule_data)
formatted_print(
res,
text_format=FORMAT_TEXT_RECORD,
fields=[("Message", "message"), ("Rule ID", "access_id")],
)