def add_switch_machine():
"""add switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.add_switch_machine(current_user, switch_id, **data)
)
def delete_switch(switch_id):
"""delete switch."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.del_switch(current_user, switch_id, **data)
)
def show_permission(permission_id):
"""Get permission."""
data = _get_request_args()
return utils.make_json_response(
200,
permission_api.get_permission(current_user, permission_id, **data)
)
def poll_switch_machines(switch_id):
"""update switch."""
data = _get_request_data()
return utils.make_json_response(
201,
switch_api.poll_switch_machines(current_user, switch_id, **data)
)
def add_cluster_config(cluster_id):
"""Update the config information for a specified cluster."""
config = json.loads(request.data)
if not config:
raise BadRequest("Config cannot be None!")
root_elems = ['os_config', 'package_config']
if len(config.keys()) != 1 or config.keys()[0] not in root_elems:
error_msg = ("Config root elements must be either"
"'os_config' or 'package_config'")
raise BadRequest(error_msg)
result = None
is_patch_method = request.method == 'PATCH'
try:
if "os_config" in config:
result = db_api.cluster\
.update_cluster_config(cluster_id,
'os_config',
config,
patch=is_patch_method)
elif "package_config" in config:
result = db_api.cluster\
.update_cluster_config(cluster_id,
'package_config', config,
patch=is_patch_method)
except InvalidParameter as ex:
raise BadRequest(ex.message)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, result)
def list_permissions():
"""List permissions."""
data = _get_request_args()
return utils.make_json_response(
200,
permission_api.list_permissions(current_user, **data)
)
def add_user():
"""add user."""
data = _get_request_data()
user_dict = user_api.add_user(current_user, **data)
return utils.make_json_response(
200, user_dict
)
def add_cluster_config(cluster_id):
"""Update the config information for a specified cluster."""
config = json.loads(request.data)
if not config:
raise BadRequest("Config cannot be None!")
root_elems = ['os_config', 'package_config']
if len(config.keys()) != 1 or config.keys()[0] not in root_elems:
error_msg = ("Config root elements must be either"
"'os_config' or 'package_config'")
raise BadRequest(error_msg)
result = None
is_patch_method = request.method == 'PATCH'
try:
if "os_config" in config:
result = db_api.update_cluster_config(cluster_id, 'os_config',
config,
patch=is_patch_method)
elif "package_config" in config:
result = db_api.update_cluster_config(cluster_id,
'package_config', config,
patch=is_patch_method)
except InvalidParameter as ex:
raise BadRequest(ex.message)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, result)
def patch_switch_filter(switch_id):
"""update switch filters."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.patch_switch_filter(current_user, switch_id, **data)
)
def _login(use_cookie):
"""User login helper function."""
data = _get_request_data()
if 'email' not in data or 'password' not in data:
raise exception_handler.BadRequest(
'missing email or password in data'
)
if 'expires' not in data:
expire_timestamp = (
datetime.datetime.now() + app.config['REMEMBER_COOKIE_DURATION']
)
else:
expire_timestamp = util.parse_datetime(
data['expires'], exception_handler.BadRequest
)
data['expire_timestamp'] = expire_timestamp
user = auth_handler.authenticate_user(**data)
if not login_user(user, remember=data.get('remember', False)):
raise exception_handler.UserDisabled('failed to login: %s' % user)
user_log_api.log_user_action(user.id, request.path)
response_data = {'id': user.id}
user_api.record_user_token(
user, user.token, user.expire_timestamp
)
if not use_cookie:
response_data['token'] = user.token
response_data['expires'] = util.format_datetime(user.expire_timestamp)
return utils.make_json_response(200, response_data)
def delete_user(user_id):
"""Delete user."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.del_user(
current_user, user_id, **data
)
)
def get_adapter_roles(adapter_id):
"""Get roles for a specified adapter."""
try:
roles = db_api.adapter.get_adapter(adapter_id, True)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, roles)
def get_adapter_roles(adapter_id):
"""Get roles for a specified adapter."""
try:
roles = db_api.get_adapter(adapter_id, True)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, roles)
def show_machine(machine_id):
"""Get machine."""
data = _get_request_args()
return utils.make_json_response(
200,
machine_api.get_machine(
current_user, machine_id, **data
)
)
def handle_bad_request(error, failed_objs=None):
"""Handler of badRequest Exception."""
message = {'type': 'badRequest', 'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(400, message)
def handle_no_permission(error, failed_objs=None):
"""Handler of Forbidden Exception."""
message = {'type': 'Forbidden', 'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(403, message)
def delete_machine(machine_id):
"""Delete machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.del_machine(
current_user, machine_id, **data
)
)
def handle_not_exist(error, failed_objs=None):
"""Handler of ItemNotFound Exception."""
message = {'type': 'itemNotFound', 'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(404, message)
def patch_machine():
"""patch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.patch_machine(
current_user, machine_id, **data
)
)
def update_machine():
"""update machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.update_machine(
current_user, machine_id, **data
)
)
def handle_invalid_user(error, failed_objs=None):
"""Handler of Unauthorized Exception."""
message = {'type': 'unathorized', 'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(401, message)
def handle_bad_request(error, failed_objs=None):
"""Handler of badRequest Exception."""
message = {'type': 'badRequest',
'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(400, message)
def handle_no_permission(error, failed_objs=None):
"""Handler of Forbidden Exception."""
message = {'type': 'Forbidden',
'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(403, message)
def handle_invalid_user(error, failed_objs=None):
"""Handler of Unauthorized Exception."""
message = {'type': 'unathorized',
'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(401, message)
def handle_not_exist(error, failed_objs=None):
"""Handler of ItemNotFound Exception."""
message = {'type': 'itemNotFound',
'message': error.message}
if failed_objs and isinstance(failed_objs, dict):
message.update(failed_objs)
return utils.make_json_response(404, message)
def get_user_permission(user_id, permission_id):
"""Get a specific user permission."""
data = _get_request_args()
return utils.make_json_response(
200,
user_api.get_permission(
current_user, user_id, permission_id
**data
)
)
def list_adapters():
""" List details of all adapters filtered by the adapter name(s)."""
names = request.args.getlist('name')
filters = {}
if names:
filters['name'] = names
adapters_list = db_api.list_adapters(filters)
return utils.make_json_response(200, adapters_list)
def delete_user_permission(user_id, permission_id):
"""Delete a specific user permission."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.del_permission(
current_user, user_id, permission_id,
**data
)
)
def get(self, adapter_id):
"""Get information for a specified adapter."""
try:
adapter_info = db_api.get_adapter(adapter_id)
except RecordNotExists as ex:
error_msg = ex.message
raise ItemNotFound(error_msg)
return utils.make_json_response(200, adapter_info)
def delete_user_actions(uesr_id):
"""Delete user actions."""
data = _get_request_data()
_filter_timestamp(data)
return utils.make_json_response(
200,
user_log_api.del_user_actions(
current_user, user_id, **data
)
)
def update_user_permissions(user_id):
"""Update user permissions."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.update_permissions(
current_user, user_id,
**data
)
)
def list_switch_filters():
"""List switch filters."""
data = _get_request_args()
_filter_ip(data)
return utils.make_json_response(
200,
switch_api.list_switch_filters(
current_user, **data
)
)
def list_user_actions(uesr_id):
"""List user actions."""
data = _get_request_args()
_filter_timestamp(data)
return utils.make_json_response(
200,
user_log_api.list_user_actions(
current_user, user_id, **data
)
)
def list_adapters():
"""List details of all adapters filtered by the adapter name(s)."""
names = request.args.getlist('name')
filters = {}
if names:
filters['name'] = names
adapters_list = db_api.adapter.list_adapters(filters)
return utils.make_json_response(200, adapters_list)
def get(self, adapter_id):
"""Get information for a specified adapter."""
try:
adapter_info = db_api.adapter.get_adapter(adapter_id)
except RecordNotExists as ex:
error_msg = ex.message
raise ItemNotFound(error_msg)
return utils.make_json_response(200, adapter_info)
def get_adapter_config_schema(adapter_id):
"""Get the config schema for a specified adapter."""
os_id = request.args.get("os-id", type=int)
try:
schema = db_api.get_adapter_config_schema(adapter_id, os_id)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, schema)
def get(self, user_id):
"""Get user's information for the specified ID."""
try:
user_data = db_api.user.get_user(user_id)
logging.debug("user_data is===>%s", user_data)
except RecordNotExists as ex:
error_msg = ex.message
raise ItemNotFound(error_msg)
return utils.make_json_response(200, user_data)
def list_machines():
"""List machines."""
data = _get_request_args()
_filter_tag(data)
_filter_location(data)
return utils.make_json_response(
200,
machine_api.list_machines(
current_user, **data
)
)
def get(self, user_id):
"""Get user's information for the specified ID."""
try:
user_data = db_api.get_user(user_id)
logging.debug("user_data is===>%s", user_data)
except RecordNotExists as ex:
error_msg = ex.message
raise ItemNotFound(error_msg)
return utils.make_json_response(200, user_data)
def get_adapter_config_schema(adapter_id):
"""Get the config schema for a specified adapter."""
os_id = request.args.get("os-id", type=int)
try:
schema = db_api.adapter.get_adapter_config_schema(adapter_id, os_id)
except RecordNotExists as ex:
raise ItemNotFound(ex.message)
return utils.make_json_response(200, schema)
def handle_exception(error):
if hasattr(error, 'to_dict'):
response = error.to_dict()
else:
response = {'message': str(error)}
if app.debug and hasattr(error, 'traceback'):
response['traceback'] = error.traceback
status_code = 400
if hasattr(error, 'status_code'):
status_code = error.status_code
return utils.make_json_response(status_code, response)
def list_users():
"""List details of all users filtered by user email and admin role."""
emails = request.args.getlist('email')
is_admin = request.args.get('admin')
filters = {}
if emails:
filters['email'] = emails
if is_admin is not None:
if is_admin == 'true':
filters['is_admin'] = True
elif is_admin == 'false':
filters['is_admin'] = False
users_list = db_api.user.list_users(filters)
return utils.make_json_response(200, users_list)
