# SPDX-License-Identifier: Apache-2.0
#
# The OpenSearch Contributors require contributions made to
# this file be licensed under the Apache-2.0 license or a
# compatible open source license.
#
# Modifications Copyright OpenSearch Contributors. See
# GitHub history for details.
# ------------------------------------------------------------------------------------------
# THIS CODE IS AUTOMATICALLY GENERATED AND MANUAL EDITS WILL BE LOST
#
# To contribute, kindly make modifications in the opensearch-py client generator
# or in the OpenSearch API specification, and run `nox -rs generate`. See DEVELOPER_GUIDE.md
# and https://github.com/opensearch-project/opensearch-api-specification for details.
# -----------------------------------------------------------------------------------------+
from typing import Any
from .utils import SKIP_IN_PATH, NamespacedClient, _make_path, query_params
[docs]class SecurityClient(NamespacedClient):
from ._patch import health_check, update_audit_config # type: ignore
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_account_details(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns account details for the current user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/account", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def change_password(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Changes the password for the current user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/account",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_action_group(
self,
action_group: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves one action group.
:arg action_group: Action group to retrieve.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if action_group in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'action_group'."
)
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "actiongroups", action_group),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_action_groups(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves all action groups.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/actiongroups",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_action_group(
self,
action_group: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Delete a specified action group.
:arg action_group: Action group to delete.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if action_group in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'action_group'."
)
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "actiongroups", action_group),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_action_group(
self,
action_group: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified action group.
:arg action_group: The name of the action group to create or
replace.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (action_group, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "actiongroups", action_group),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_action_group(
self,
action_group: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates individual attributes of an action group.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (action_group, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "actiongroups", action_group),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_action_groups(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates, updates, or deletes multiple action groups in a single call.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/actiongroups",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_user(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieve one internal user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "internalusers", username),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_users(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieve all internal users.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/internalusers",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_user(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Delete the specified user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "internalusers", username),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_user(
self,
username: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (username, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "internalusers", username),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_user(
self,
username: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates individual attributes of an internal user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (username, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "internalusers", username),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_users(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates, updates, or deletes multiple internal users in a single call.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/internalusers",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_role(
self,
role: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves one role.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if role in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'role'.")
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "roles", role),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_roles(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves all roles.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/roles", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_role(
self,
role: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Delete the specified role.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if role in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'role'.")
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "roles", role),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_role(
self,
role: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified role.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (role, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "roles", role),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_role(
self,
role: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates individual attributes of a role.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (role, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "roles", role),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_roles(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates, updates, or deletes multiple roles in a single call.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/roles",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_role_mapping(
self,
role: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves one role mapping.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if role in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'role'.")
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "rolesmapping", role),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_role_mappings(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves all role mappings.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/rolesmapping",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_role_mapping(
self,
role: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes the specified role mapping.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if role in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'role'.")
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "rolesmapping", role),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_role_mapping(
self,
role: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified role mapping.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (role, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "rolesmapping", role),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_role_mapping(
self,
role: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates individual attributes of a role mapping.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (role, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "rolesmapping", role),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_role_mappings(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or updates multiple role mappings in a single call.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/rolesmapping",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_tenant(
self,
tenant: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves one tenant.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if tenant in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'tenant'.")
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "tenants", tenant),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_tenants(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves all tenants.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/tenants", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_tenant(
self,
tenant: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Delete the specified tenant.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if tenant in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'tenant'.")
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "tenants", tenant),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_tenant(
self,
tenant: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified tenant.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (tenant, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "tenants", tenant),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_tenant(
self,
tenant: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Add, delete, or modify a single tenant.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (tenant, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "tenants", tenant),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_tenants(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Add, delete, or modify multiple tenants in a single call.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/tenants",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_configuration(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns the current Security plugin configuration in JSON format.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/securityconfig",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def update_configuration(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Adds or updates the existing configuration using the REST API. Only accessible
by admins and users with rest api access and only when put or patch is enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/securityconfig/config",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_configuration(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
A PATCH call is used to update the existing configuration using the REST API.
Only accessible by admins and users with rest api access and only when put or
patch is enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/securityconfig",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "show_all", "source")
def get_distinguished_names(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves distinguished names. Only accessible to super-admins and with rest-
api permissions when enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/nodesdn", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_certificates(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the cluster security certificates.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/ssl/certs", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def reload_transport_certificates(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Reload Transport layer communication certificates.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/ssl/transport/reloadcerts",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def reload_http_certificates(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Reload HTTP layer communication certificates.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/ssl/http/reloadcerts",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def flush_cache(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Flushes the Security plugin user, authentication, and authorization cache.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"DELETE", "/_plugins/_security/api/cache", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "mode", "pretty", "source")
def health(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Checks to see if the Security plugin is up and running.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/health", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_audit_configuration(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the audit configuration.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/audit", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def update_audit_configuration(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates the audit configuration.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/audit/config",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_audit_configuration(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
A PATCH call is used to update specified fields in the audit configuration.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/audit",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_distinguished_names(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Bulk update of distinguished names. Only accessible to super-admins and with
rest-api permissions when enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/nodesdn",
params=params,
headers=headers,
body=body,
)
[docs] @query_params(
"auth_type",
"error_trace",
"filter_path",
"human",
"pretty",
"source",
"verbose",
)
def authinfo(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns the authentication information.
:arg auth_type: The type of current authentication request.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg verbose: Indicates whether a verbose response should be
returned.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/authinfo", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def authtoken(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns the authorization token.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"POST", "/_plugins/_security/api/authtoken", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def cache(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Not supported for cache API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"PUT", "/_plugins/_security/api/cache", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def config_upgrade_check(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Check whether or not an upgrade can be performed and what resources can be
updated.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/_upgrade_check", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_allowlist(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the allowlisted APIs. Accessible via Super Admin
certificate or REST API permission.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/allowlist",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_update_tenancy_config(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the multi-tenancy configuration. Only accessible to admins
and users with REST API permissions.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PUT",
"/_plugins/_security/api/tenancy/config",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def create_user_legacy(
self,
username: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or replaces the specified user. Legacy API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
for param in (username, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "user", username),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_distinguished_name(
self,
cluster_name: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes all distinguished names in the specified cluster or node allow list.
Only accessible to super-admins and with rest-api permissions when enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if cluster_name in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'cluster_name'."
)
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "nodesdn", cluster_name),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def delete_user_legacy(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Delete the specified user. Legacy API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"DELETE",
_make_path("_plugins", "_security", "api", "user", username),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def generate_obo_token(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Generates On-Behalf-Of token for the current user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"POST",
"/_plugins/_security/api/generateonbehalfoftoken",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def generate_user_token(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Generates authorization token for the given user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"POST",
_make_path(
"_plugins", "_security", "api", "internalusers", username, "authtoken"
),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def generate_user_token_legacy(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Generates authorization token for the given user. Legacy API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"POST",
_make_path("_plugins", "_security", "api", "user", username, "authtoken"),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_allowlist(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the current list of allowed API accessible to normal user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/allowlist", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_dashboards_info(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the current security-dashboards plugin configuration.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/dashboardsinfo", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "show_all", "source")
def get_distinguished_name(
self,
cluster_name: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves distinguished names. Only accessible to super-admins and with rest-
api permissions when enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if cluster_name in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'cluster_name'."
)
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "nodesdn", cluster_name),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_permissions_info(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Gets the evaluated REST API permissions for the currently logged in user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/permissionsinfo",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "show_dn", "source")
def get_sslinfo(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the SSL configuration information.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg show_dn: The domain names from all certificates.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_opendistro/_security/sslinfo", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_tenancy_config(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves multi-tenancy configuration. Only accessible to admins and users with
REST API permissions.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET",
"/_plugins/_security/api/tenancy/config",
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_user_legacy(
self,
username: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieve one user. Legacy API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if username in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'username'.")
return self.transport.perform_request(
"GET",
_make_path("_plugins", "_security", "api", "user", username),
params=params,
headers=headers,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def get_users_legacy(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieve all internal users. Legacy API.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/user", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def migrate(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Migrates security configuration from v6 to v7.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"POST", "/_plugins/_security/api/migrate", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_allowlist(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates the current list of allowed API accessible to normal user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return self.transport.perform_request(
"PATCH",
"/_plugins/_security/api/allowlist",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def patch_distinguished_name(
self,
cluster_name: Any,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates a distinguished cluster name for a specific cluster. Only accessible to
super-admins and with rest-api permissions when enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if cluster_name in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'cluster_name'."
)
return self.transport.perform_request(
"PATCH",
_make_path("_plugins", "_security", "api", "nodesdn", cluster_name),
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def post_dashboards_info(
self,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates the current security-dashboards plugin configuration.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"POST",
"/_plugins/_security/dashboardsinfo",
params=params,
headers=headers,
body=body,
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def tenant_info(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Retrieves the tenant names if any exist. Only accesible to super admins or
kibanaserver user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/tenantinfo", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def update_distinguished_name(
self,
cluster_name: Any,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Adds or updates the specified distinguished names in the cluster or node allow
list. Only accessible to super-admins and with rest-api permissions when
enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if cluster_name in SKIP_IN_PATH:
raise ValueError(
"Empty value passed for a required argument 'cluster_name'."
)
return self.transport.perform_request(
"PUT",
_make_path("_plugins", "_security", "api", "nodesdn", cluster_name),
params=params,
headers=headers,
body=body,
)
[docs] @query_params(
"accept_invalid", "error_trace", "filter_path", "human", "pretty", "source"
)
def validate(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Checks whether the v6 security configuration is valid and ready to be migrated
to v7.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/api/validate", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def who_am_i(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Gets the user identity related information for currently logged in user.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/whoami", params=params, headers=headers
)
[docs] @query_params("error_trace", "filter_path", "human", "pretty", "source")
def who_am_i_protected(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Gets the user identity related information for currently logged in user. User
needs to have access to this endpoint when authorization at REST layer is
enabled.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return self.transport.perform_request(
"GET", "/_plugins/_security/whoamiprotected", params=params, headers=headers
)