x/compass-core
Code Issues Proposed changes
Files
ea5fb8ad4f24169e6b3f2705e6ce3edb8a08307c
compass-core/compass/api/api.py
Lei Lei 5345a81470 Enable to get flavor_metadata without creating cluster. 
1.Add "list_flavors" and "get_flavor" in api.
2.User "get_flavor" to get flavor name.
3.Add unittest for the new api function.
4.remove "ha_proxy" from package_matadata/openstack.conf
5.add flavor_config_validates

Change-Id: Ib17b851f5d8ac14b6d2bb13b0f44b575936c9f74
2015-04-27 15:10:00 -07:00

2720 lines
68 KiB
Python
Raw Blame History

#!/usr/bin/python
# Copyright 2014 Huawei Technologies Co. Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Define all the RestfulAPI entry points."""
import datetime
import functools
import logging
import netaddr
import requests
import simplejson as json
from flask.ext.login import current_user
from flask.ext.login import login_required
from flask.ext.login import login_user
from flask.ext.login import logout_user
from flask import request
from compass.api import app
from compass.api import auth_handler
from compass.api import exception_handler
from compass.api import utils
from compass.db.api import adapter_holder as adapter_api
from compass.db.api import cluster as cluster_api
from compass.db.api import database
from compass.db.api import health_check_report as health_report_api
from compass.db.api import host as host_api
from compass.db.api import machine as machine_api
from compass.db.api import metadata_holder as metadata_api
from compass.db.api import network as network_api
from compass.db.api import permission as permission_api
from compass.db.api import switch as switch_api
from compass.db.api import user as user_api
from compass.db.api import user_log as user_log_api
from compass.utils import flags
from compass.utils import logsetting
from compass.utils import setting_wrapper as setting
from compass.utils import util
def log_user_action(func):
@functools.wraps(func)
def decorated_api(*args, **kwargs):
user_log_api.log_user_action(current_user.id, request.path)
return func(*args, **kwargs)
return decorated_api
def update_user_token(func):
@functools.wraps(func)
def decorated_api(*args, **kwargs):
response = func(*args, **kwargs)
expire_timestamp = (
datetime.datetime.now() + app.config['REMEMBER_COOKIE_DURATION']
)
user_api.record_user_token(
current_user.token, expire_timestamp, user=current_user
)
return response
return decorated_api
def _clean_data(data, keys):
for key in keys:
if key in data:
del data[key]
def _replace_data(data, key_mapping):
for key, replaced_key in key_mapping.items():
if key in data:
data[replaced_key] = data[key]
del data[key]
def _get_data(data, key):
if key in data:
if isinstance(data[key], list):
if data[key]:
if len(data[key]) == 1:
return data[key][0]
else:
raise exception_handler.BadRequest(
'%s declared multi times %s in request' % (
key, data[key]
)
)
else:
return None
else:
return data[key]
else:
return None
def _get_data_list(data, key):
if key in data:
if isinstance(data[key], list):
return data[key]
else:
return [data[key]]
else:
return []
def _get_request_data():
if request.data:
try:
return json.loads(request.data)
except Exception:
raise exception_handler.BadRequest(
'request data is not json formatted: %s' % request.data
)
else:
return {}
def _get_request_data_as_list():
if request.data:
try:
return json.loads(request.data)
except Exception:
raise exception_handler.BadRequest(
'request data is not json formatted: %s' % request.data
)
else:
return []
def _bool_converter(value):
if not value:
return True
if value in ['False', 'false', '0']:
return False
return True
def _int_converter(value):
try:
return int(value)
except Exception:
raise exception_handler.BadRequest(
'%r type is not int' % value
)
def _get_request_args(**kwargs):
args = dict(request.args)
logging.debug('origin request args: %s', args)
for key, value in args.items():
if key in kwargs:
converter = kwargs[key]
if isinstance(value, list):
args[key] = [converter(item) for item in value]
else:
args[key] = converter(value)
logging.debug('request args: %s', args)
return args
def _group_data_action(data, **data_callbacks):
if not data:
raise exception_handler.BadRequest(
'no action to take'
)
unsupported_keys = list(set(data) - set(data_callbacks))
if unsupported_keys:
raise exception_handler.BadMethod(
'unsupported actions: %s' % unsupported_keys
)
callback_datas = {}
for data_key, data_value in data.items():
callback = data_callbacks[data_key]
callback_datas.setdefault(id(callback), {})[data_key] = data_value
if len(callback_datas) > 1:
raise exception_handler.BadRequest(
'multi actions are not supported'
)
callback_ids = {}
for data_key, data_callback in data_callbacks.items():
callback_ids[id(data_callback)] = data_callback
for callback_id, callback_data in callback_datas.items():
return callback_ids[callback_id](**callback_data)
def _wrap_response(func, response_code):
def wrapped_func(*args, **kwargs):
return utils.make_json_response(
response_code,
func(*args, **kwargs)
)
return wrapped_func
def _reformat_host_networks(networks):
network_mapping = {}
for network in networks:
if 'interface' in network:
network_mapping[network['interface']] = network
return network_mapping
def _reformat_host(host):
if isinstance(host, list):
return [_reformat_host(item) for item in host]
if 'networks' in host:
host['networks'] = _reformat_host_networks(host['networks'])
return host
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'
)
expire_timestamp = (
datetime.datetime.now() + app.config['REMEMBER_COOKIE_DURATION']
)
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 = user_api.record_user_token(
user.token, user.expire_timestamp, user=user
)
return utils.make_json_response(200, response_data)
@app.route('/users/token', methods=['POST'])
def get_token():
"""Get token from email and password after user authentication."""
return _login(False)
@app.route("/users/login", methods=['POST'])
def login():
"""User login."""
return _login(True)
@app.route('/users/logout', methods=['POST'])
@login_required
def logout():
"""User logout."""
user_log_api.log_user_action(current_user.id, request.path)
response_data = user_api.clean_user_token(
current_user.token, user=current_user
)
logout_user()
return utils.make_json_response(200, response_data)
@app.route("/users", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_users():
"""list users."""
data = _get_request_args(
is_admin=_bool_converter,
active=_bool_converter
)
return utils.make_json_response(
200, user_api.list_users(user=current_user, **data)
)
@app.route("/users", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_user():
"""add user."""
data = _get_request_data()
user_dict = user_api.add_user(user=current_user, **data)
return utils.make_json_response(
200, user_dict
)
@app.route("/users/<int:user_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_user(user_id):
"""Get user."""
data = _get_request_args()
return utils.make_json_response(
200, user_api.get_user(user_id, user=current_user, **data)
)
@app.route("/current-user", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_current_user():
"""Get user."""
data = _get_request_args()
return utils.make_json_response(
200, user_api.get_current_user(user=current_user, **data)
)
@app.route("/users/<int:user_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_user(user_id):
"""Update user."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.update_user(
user_id,
user=current_user,
**data
)
)
@app.route("/users/<int:user_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_user(user_id):
"""Delete user."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.del_user(
user_id, user=current_user, **data
)
)
@app.route("/users/<int:user_id>/permissions", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_user_permissions(user_id):
"""Get user permissions."""
data = _get_request_args()
return utils.make_json_response(
200, user_api.get_permissions(user_id, user=current_user, **data)
)
@app.route("/users/<int:user_id>/action", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def take_user_action(user_id):
"""Take user action."""
data = _get_request_data()
update_permissions_func = _wrap_response(
functools.partial(
user_api.update_permissions, user_id, user=current_user,
),
200
)
def disable_user(disable_user=None):
return user_api.update_user(
user_id, user=current_user, active=False
)
disable_user_func = _wrap_response(
disable_user,
200
)
def enable_user(enable_user=None):
return user_api.update_user(
user_id, user=current_user, active=True
)
enable_user_func = _wrap_response(
enable_user,
200
)
return _group_data_action(
data,
add_permissions=update_permissions_func,
remove_permissions=update_permissions_func,
set_permissions=update_permissions_func,
enable_user=enable_user_func,
disable_user=disable_user_func
)
@app.route(
'/users/<int:user_id>/permissions/<int:permission_id>',
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_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(
user_id, permission_id, user=current_user,
**data
)
)
@app.route("/users/<int:user_id>/permissions", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_user_permission(user_id):
"""Add permission to a specific user."""
data = _get_request_data()
return utils.make_json_response(
200,
user_api.add_permission(
user_id, user=current_user,
**data
)
)
@app.route(
'/users/<int:user_id>/permissions/<int:permission_id>',
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
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(
user_id, permission_id, user=current_user,
**data
)
)
@app.route("/permissions", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_permissions():
"""List permissions."""
data = _get_request_args()
return utils.make_json_response(
200,
permission_api.list_permissions(user=current_user, **data)
)
@app.route("/permissions/<int:permission_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_permission(permission_id):
"""Get permission."""
data = _get_request_args()
return utils.make_json_response(
200,
permission_api.get_permission(permission_id, user=current_user, **data)
)
def _filter_timestamp(data):
timestamp_filter = {}
start = _get_data(data, 'timestamp_start')
if start is not None:
timestamp_filter['ge'] = util.parse_datetime(
start, exception_handler.BadRequest
)
end = _get_data(data, 'timestamp_end')
if end is not None:
timestamp_filter['le'] = util.parse_datetime(
end, exception_handler.BadRequest)
range = _get_data_list(data, 'timestamp_range')
if range:
timestamp_filter['between'] = []
for value in range:
timestamp_filter['between'].append(
util.parse_datetime_range(
value, exception_handler.BadRequest
)
)
data['timestamp'] = timestamp_filter
_clean_data(
data,
[
'timestamp_start', 'timestamp_end',
'timestamp_range'
]
)
@app.route("/users/logs", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_all_user_actions():
"""List all users actions."""
data = _get_request_args()
_filter_timestamp(data)
return utils.make_json_response(
200,
user_log_api.list_actions(
user=current_user, **data
)
)
@app.route("/users/<int:user_id>/logs", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_user_actions(user_id):
"""List user actions."""
data = _get_request_args()
_filter_timestamp(data)
return utils.make_json_response(
200,
user_log_api.list_user_actions(
user_id, user=current_user, **data
)
)
@app.route("/users/logs", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_all_user_actions():
"""Delete all user actions."""
data = _get_request_data()
return utils.make_json_response(
200,
user_log_api.del_actions(
user=current_user, **data
)
)
@app.route("/users/<int:user_id>/logs", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_user_actions(user_id):
"""Delete user actions."""
data = _get_request_data()
return utils.make_json_response(
200,
user_log_api.del_user_actions(
user_id, user=current_user, **data
)
)
def _filter_ip(data):
ip_filter = {}
switch_ips = _get_data_list(data, 'switchIp')
if switch_ips:
ip_filter['eq'] = []
for switch_ip in switch_ips:
ip_filter['eq'].append(long(netaddr.IPAddress(switch_ip)))
switch_start = _get_data(data, 'switchIpStart')
if switch_start is not None:
ip_filter['ge'] = long(netaddr.IPAddress(switch_start))
switch_end = _get_data(data, 'switchIpEnd')
if switch_end is not None:
ip_filter['lt'] = long(netaddr.IPAddress(switch_end))
switch_nets = _get_data_list(data, 'switchIpNetwork')
if switch_nets:
ip_filter['between'] = []
for switch_net in switch_nets:
network = netaddr.IPNetwork(switch_net)
ip_filter['between'].append((network.first, network.last))
switch_ranges = _get_data_list(data, 'switchIpRange')
if switch_ranges:
ip_filter.setdefault('between', [])
for switch_range in switch_ranges:
ip_start, ip_end = switch_range.split(',')
ip_filter['between'].append(
long(netaddr.IPAddress(ip_start)),
long(netaddr.IPAddress(ip_end))
)
if ip_filter:
data['ip_int'] = ip_filter
_clean_data(
data,
[
'switchIp', 'switchIpStart', 'switchIpEnd',
'switchIpNetwork', 'switchIpRange'
]
)
@app.route("/switches", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_switches():
"""List switches."""
data = _get_request_args()
_filter_ip(data)
return utils.make_json_response(
200,
switch_api.list_switches(
user=current_user, **data
)
)
@app.route("/switches/<int:switch_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_switch(switch_id):
"""Get switch."""
data = _get_request_args()
return utils.make_json_response(
200, switch_api.get_switch(switch_id, user=current_user, **data)
)
@app.route("/switches", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_switch():
"""add switch."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.add_switch(user=current_user, **data)
)
@app.route("/switches/<int:switch_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_switch(switch_id):
"""update switch."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.update_switch(switch_id, user=current_user, **data)
)
@app.route("/switches/<int:switch_id>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_switch(switch_id):
"""patch switch."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.patch_switch(switch_id, user=current_user, **data)
)
@app.route("/switches/<int:switch_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_switch(switch_id):
"""delete switch."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.del_switch(switch_id, user=current_user, **data)
)
@app.route("/switch-filters", methods=['GET'])
@log_user_action
@login_required
@update_user_token
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(
user=current_user, **data
)
)
@app.route("/switch-filters/<int:switch_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_switch_filters(switch_id):
"""Get switch filters."""
data = _get_request_args()
return utils.make_json_response(
200,
switch_api.get_switch_filters(switch_id, user=current_user, **data)
)
@app.route("/switch-filters/<int:switch_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_switch_filters(switch_id):
"""update switch filters."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.update_switch_filters(switch_id, user=current_user, **data)
)
@app.route("/switch-filters/<int:switch_id>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_switch_filters(switch_id):
"""patch switch filters."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.patch_switch_filter(switch_id, user=current_user, **data)
)
def _filter_port(data):
port_filter = {}
ports = _get_data_list(data, 'port')
if ports:
port_filter['eq'] = ports
port_start = _get_data(data, 'portStart')
if port_start is not None:
port_filter['resp_ge'] = int(port_start)
port_end = _get_data(data, 'portEnd')
if port_end is not None:
port_filter['resp_lt'] = int(port_end)
port_ranges = _get_data_list(data, 'portRange')
if port_ranges:
port_filter['resp_range'] = []
for port_range in port_ranges:
port_start, port_end = port_range.split(',')
port_filter['resp_range'].append(
(int(port_start), int(port_end))
)
port_prefix = _get_data(data, 'portPrefix')
if port_prefix:
port_filter['startswith'] = port_prefix
port_suffix = _get_data(data, 'portSuffix')
if port_suffix:
port_filter['endswith'] = port_suffix
if port_filter:
data['port'] = port_filter
_clean_data(
data,
[
'portStart', 'portEnd', 'portRange',
'portPrefix', 'portSuffix'
]
)
def _filter_general(data, key):
general_filter = {}
general = _get_data_list(data, key)
if general:
general_filter['resp_in'] = general
data[key] = general_filter
def _filter_tag(data):
tag_filter = {}
tags = _get_data_list(data, 'tag')
if tags:
tag_filter['resp_in'] = []
for tag in tags:
tag_filter['resp_in'].append(
util.parse_request_arg_dict(tag)
)
data['tag'] = tag_filter
def _filter_location(data):
location_filter = {}
locations = _get_data_list(data, 'location')
if locations:
location_filter['resp_in'] = []
for location in locations:
location_filter['resp_in'].append(
util.parse_request_arg_dict(location)
)
data['location'] = location_filter
@app.route("/switches/<int:switch_id>/machines", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_switch_machines(switch_id):
"""Get switch machines."""
data = _get_request_args(vlans=_int_converter)
_filter_port(data)
_filter_general(data, 'vlans')
_filter_tag(data)
_filter_location(data)
return utils.make_json_response(
200,
switch_api.list_switch_machines(
switch_id, user=current_user, **data
)
)
@app.route("/switches/<int:switch_id>/machines-hosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_switch_machines_hosts(switch_id):
"""Get switch machines or hosts."""
data = _get_request_args(vlans=_int_converter, os_id=_int_converter)
_filter_port(data)
_filter_general(data, 'vlans')
_filter_tag(data)
_filter_location(data)
_filter_general(data, 'os_name')
_filter_general(data, 'os_id')
return utils.make_json_response(
200,
switch_api.list_switch_machines_hosts(
switch_id, user=current_user, **data
)
)
@app.route("/switches/<int:switch_id>/machines", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_switch_machine(switch_id):
"""add switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.add_switch_machine(switch_id, user=current_user, **data)
)
@app.route(
'/switches/<int:switch_id>/machines/<int:machine_id>',
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_switch_machine(switch_id, machine_id):
"""get switch machine."""
data = _get_request_args()
return utils.make_json_response(
200,
switch_api.get_switch_machine(
switch_id, machine_id, user=current_user, **data
)
)
@app.route(
'/switches/<int:switch_id>/machines/<int:machine_id>',
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_switch_machine(switch_id, machine_id):
"""update switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.update_switch_machine(
switch_id, machine_id, user=current_user, **data
)
)
@app.route(
'/switches/<int:switch_id>/machines/<int:machine_id>',
methods=['PATCH']
)
@log_user_action
@login_required
@update_user_token
def patch_switch_machine(switch_id, machine_id):
"""patch switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.patch_switch_machine(
current_user, switch_id, machine_id, **data
)
)
@app.route(
'/switches/<int:switch_id>/machines/<int:machine_id>',
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
def delete_switch_machine(switch_id, machine_id):
"""Delete switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.del_switch_machine(
switch_id, machine_id, user=current_user, **data
)
)
@app.route("/switches/<int:switch_id>/action", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def take_switch_action(switch_id):
"""update switch."""
data = _get_request_data()
poll_switch_machines_func = _wrap_response(
functools.partial(
switch_api.poll_switch_machines, switch_id, user=current_user,
),
202
)
update_switch_machines_func = _wrap_response(
functools.partial(
switch_api.update_switch_machines, switch_id, user=current_user,
),
200
)
return _group_data_action(
data,
find_machines=poll_switch_machines_func,
add_machines=update_switch_machines_func,
remove_machines=update_switch_machines_func,
set_machines=update_switch_machines_func
)
@app.route("/machines/<int:machine_id>/action", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def take_machine_action(machine_id):
"""update machine."""
data = _get_request_data()
tag_func = _wrap_response(
functools.partial(
machine_api.update_machine, machine_id, user=current_user,
),
200
)
poweron_func = _wrap_response(
functools.partial(
machine_api.poweron_machine, machine_id, user=current_user,
),
202
)
poweroff_func = _wrap_response(
functools.partial(
machine_api.poweroff_machine, machine_id, user=current_user,
),
202
)
reset_func = _wrap_response(
functools.partial(
machine_api.reset_machine, machine_id, user=current_user,
),
202
)
return _group_data_action(
data,
tag=tag_func,
poweron=poweron_func,
poweroff=poweroff_func,
reset=reset_func
)
@app.route("/switch-machines", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_switchmachines():
"""List switch machines."""
data = _get_request_args(vlans=_int_converter)
_filter_ip(data)
_filter_port(data)
_filter_general(data, 'vlans')
_filter_tag(data)
_filter_location(data)
return utils.make_json_response(
200,
switch_api.list_switchmachines(
user=current_user, **data
)
)
@app.route("/switches-machines-hosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_switchmachines_hosts():
"""List switch machines or hosts."""
data = _get_request_args(vlans=_int_converter, os_id=_int_converter)
_filter_ip(data)
_filter_port(data)
_filter_general(data, 'vlans')
_filter_tag(data)
_filter_location(data)
_filter_general(data, 'os_name')
_filter_general(data, 'os_id')
return utils.make_json_response(
200,
switch_api.list_switchmachines_hosts(
user=current_user, **data
)
)
@app.route(
'/switch-machines/<int:switch_machine_id>',
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_switchmachine(switch_machine_id):
"""get switch machine."""
data = _get_request_args()
return utils.make_json_response(
200,
switch_api.get_switchmachine(
switch_machine_id, user=current_user, **data
)
)
@app.route(
'/switch-machines/<int:switch_machine_id>',
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_switchmachine(switch_machine_id):
"""update switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.update_switchmachine(
switch_machine_id, user=current_user, **data
)
)
@app.route('/switch-machines/<int:switch_machine_id>', methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_switchmachine(switch_machine_id):
"""patch switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.patch_switchmachine(
switch_machine_id, user=current_user, **data
)
)
@app.route("/switch-machines/<int:switch_machine_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_switchmachine(switch_machine_id):
"""Delete switch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
switch_api.del_switchmachine(
switch_machine_id, user=current_user, **data
)
)
@app.route("/machines", methods=['GET'])
@log_user_action
@login_required
@update_user_token
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(
user=current_user, **data
)
)
@app.route("/machines/<int:machine_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_machine(machine_id):
"""Get machine."""
data = _get_request_args()
return utils.make_json_response(
200,
machine_api.get_machine(
machine_id, user=current_user, **data
)
)
@app.route("/machines/<int:machine_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_machine(machine_id):
"""update machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.update_machine(
machine_id, user=current_user, **data
)
)
@app.route("/machines/<int:machine_id>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_machine(machine_id):
"""patch machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.patch_machine(
machine_id, user=current_user, **data
)
)
@app.route("/machines/<int:machine_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_machine(machine_id):
"""Delete machine."""
data = _get_request_data()
return utils.make_json_response(
200,
machine_api.del_machine(
machine_id, user=current_user, **data
)
)
@app.route("/subnets", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_subnets():
"""List subnets."""
data = _get_request_args()
return utils.make_json_response(
200,
network_api.list_subnets(
user=current_user, **data
)
)
@app.route("/subnets/<int:subnet_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_subnet(subnet_id):
"""Get subnet."""
data = _get_request_args()
return utils.make_json_response(
200,
network_api.get_subnet(
subnet_id, user=current_user, **data
)
)
@app.route("/subnets", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_subnet():
"""add subnet."""
data = _get_request_data()
return utils.make_json_response(
200,
network_api.add_subnet(user=current_user, **data)
)
@app.route("/subnets/<int:subnet_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_subnet(subnet_id):
"""update subnet."""
data = _get_request_data()
return utils.make_json_response(
200,
network_api.update_subnet(
subnet_id, user=current_user, **data
)
)
@app.route("/subnets/<int:subnet_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_subnet(subnet_id):
"""Delete subnet."""
data = _get_request_data()
return utils.make_json_response(
200,
network_api.del_subnet(
subnet_id, user=current_user, **data
)
)
@app.route("/adapters", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_adapters():
"""List adapters."""
data = _get_request_args()
_filter_general(data, 'name')
_filter_general(data, 'distributed_system_name')
_filter_general(data, 'os_installer_name')
_filter_general(data, 'package_installer_name')
return utils.make_json_response(
200,
adapter_api.list_adapters(
user=current_user, **data
)
)
@app.route("/adapters/<int:adapter_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_adapter(adapter_id):
"""Get adapter."""
data = _get_request_args()
return utils.make_json_response(
200,
adapter_api.get_adapter(
adapter_id, user=current_user, **data
)
)
@app.route("/adapters/<int:adapter_id>/metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_adapter_metadata(adapter_id):
"""Get adapter metadata."""
data = _get_request_args()
return utils.make_json_response(
200,
metadata_api.get_package_metadata(
adapter_id, user=current_user, **data
)
)
@app.route("/oses/<int:os_id>/metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_os_metadata(os_id):
"""Get os metadata."""
data = _get_request_args()
return utils.make_json_response(
200,
metadata_api.get_os_metadata(
os_id, user=current_user, **data
)
)
@app.route("/oses/<int:os_id>/ui_metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def convert_os_metadata(os_id):
"""Convert os metadata to ui os metadata."""
metadatas = metadata_api.get_os_metadata(
os_id, user=current_user
)
configs = util.load_configs(setting.OS_MAPPING_DIR)
metadata = metadatas['os_config']
config = configs[0]['OS_CONFIG_MAPPING']
return utils.make_json_response(
200,
metadata_api.get_ui_metadata(
metadata, config
)
)
@app.route("/flavors/<int:flavor_id>/metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_flavor_metadata(flavor_id):
"""Get flavor metadata."""
data = _get_request_args()
return utils.make_json_response(
200,
metadata_api.get_flavor_metadata(
flavor_id, user=current_user, **data
)
)
@app.route("/flavors/<int:flavor_id>/ui_metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def convert_flavor_metadata(flavor_id):
"""Convert flavor metadat to ui flavor metadata."""
metadatas = metadata_api.get_flavor_metadata(
flavor_id, user=current_user
)
metadata = metadatas['flavor_config']
flavor = metadata_api.get_flavor(
flavor_id,
user=current_user
)
flavor_name = flavor['name'].replace('-', '_')
configs = util.load_configs(setting.FLAVOR_MAPPING_DIR)
for item in configs:
if flavor_name in item.keys():
config = item[flavor_name]
return utils.make_json_response(
200,
metadata_api.get_ui_metadata(
metadata, config
)
)
@app.route(
"/adapters/<int:adapter_id>/oses/<int:os_id>/metadata",
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_adapter_os_metadata(adapter_id, os_id):
"""Get adapter metadata."""
data = _get_request_args()
return utils.make_json_response(
200,
metadata_api.get_package_os_metadata(
adapter_id, os_id, user=current_user, **data
)
)
@app.route("/clusters", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_clusters():
"""List clusters."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.list_clusters(
user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_cluster(cluster_id):
"""Get cluster."""
data = _get_request_args(adapter_id=_int_converter)
return utils.make_json_response(
200,
cluster_api.get_cluster(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_cluster():
"""add cluster."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.add_cluster(user=current_user, **data)
)
@app.route("/clusters/<int:cluster_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_cluster(cluster_id):
"""update cluster."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_cluster(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_cluster(cluster_id):
"""Delete cluster."""
data = _get_request_data()
response = cluster_api.del_cluster(
cluster_id, user=current_user, **data
)
if 'status' in response:
return utils.make_json_response(
202, response
)
else:
return utils.make_json_response(
200, response
)
@app.route("/clusters/<int:cluster_id>/config", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_cluster_config(cluster_id):
"""Get cluster config."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_cluster_config(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>/metadata", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_cluster_metadata(cluster_id):
"""Get cluster config."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_cluster_metadata(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>/config", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_cluster_config(cluster_id):
"""update cluster config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_cluster_config(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>/config", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_cluster_config(cluster_id):
"""patch cluster config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.patch_cluster_config(cluster_id, user=current_user, **data)
)
@app.route("/clusters/<int:cluster_id>/config", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_cluster_config(cluster_id):
"""Delete cluster config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.del_cluster_config(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>/action", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def take_cluster_action(cluster_id):
"""take cluster action."""
data = _get_request_data()
url_root = request.url_root
update_cluster_hosts_func = _wrap_response(
functools.partial(
cluster_api.update_cluster_hosts, cluster_id, user=current_user,
),
200
)
review_cluster_func = _wrap_response(
functools.partial(
cluster_api.review_cluster, cluster_id, user=current_user,
),
200
)
deploy_cluster_func = _wrap_response(
functools.partial(
cluster_api.deploy_cluster, cluster_id, user=current_user,
),
202
)
check_cluster_health_func = _wrap_response(
functools.partial(
health_report_api.start_check_cluster_health,
current_user, cluster_id,
'%s/clusters/%s/healthreports' % (url_root, cluster_id)
),
202
)
return _group_data_action(
data,
add_hosts=update_cluster_hosts_func,
set_hosts=update_cluster_hosts_func,
remove_hosts=update_cluster_hosts_func,
review=review_cluster_func,
deploy=deploy_cluster_func,
check_health=check_cluster_health_func
)
@app.route("/clusters/<int:cluster_id>/state", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def get_cluster_state(cluster_id):
"""Get cluster state."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_cluster_state(
cluster_id, user=current_user, **data
)
)
@app.route("/clusters/<int:cluster_id>/healthreports", methods=['POST'])
def create_health_reports(cluster_id):
"""Create a health check report."""
data = _get_request_data()
output = []
if 'report_list' in data:
for report in data['report_list']:
try:
output.append(
health_report_api.add_report_record(cluster_id, **report)
)
except Exception:
continue
else:
output = health_report_api.add_report_record(cluster_id, **data)
return utils.make_json_response(
200,
output
)
@app.route("/clusters/<int:cluster_id>/healthreports", methods=['PUT'])
def bulk_update_reports(cluster_id):
"""Bulk update reports."""
data = _get_request_data()
return utils.make_json_response(
200,
health_report_api.update_multi_reports(cluster_id, **data)
)
@app.route("/clusters/<int:cluster_id>/healthreports", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_health_reports(cluster_id):
return utils.make_json_response(
200,
health_report_api.list_health_reports(current_user, cluster_id)
)
@app.route("/clusters/<int:cluster_id>/healthreports/<name>", methods=['PUT'])
def update_health_report(cluster_id, name):
data = _get_request_data()
if 'error_message' not in data:
data['error_message'] = ""
return utils.make_json_response(
200,
health_report_api.update_report(cluster_id, name, **data)
)
@app.route("/clusters/<int:cluster_id>/healthreports/<name>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def get_health_report(cluster_id, name):
return utils.make_json_response(
200,
health_report_api.get_health_report(current_user, cluster_id, name)
)
@app.route("/clusters/<int:cluster_id>/hosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_cluster_hosts(cluster_id):
"""Get cluster hosts."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(cluster_api.list_cluster_hosts(
cluster_id, user=current_user, **data
))
)
@app.route("/clusterhosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_clusterhosts():
"""Get cluster hosts."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(cluster_api.list_clusterhosts(
user=current_user, **data
))
)
@app.route("/clusters/<int:cluster_id>/hosts/<int:host_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_cluster_host(cluster_id, host_id):
"""Get clusterhost."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(cluster_api.get_cluster_host(
cluster_id, host_id, user=current_user, **data
))
)
@app.route("/clusterhosts/<int:clusterhost_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_clusterhost(clusterhost_id):
"""Get clusterhost."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(cluster_api.get_clusterhost(
clusterhost_id, user=current_user, **data
))
)
@app.route("/clusters/<int:cluster_id>/hosts", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_cluster_host(cluster_id):
"""update cluster hosts."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.add_cluster_host(cluster_id, user=current_user, **data)
)
@app.route(
'/clusters/<int:cluster_id>/hosts/<int:host_id>',
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_cluster_host(cluster_id, host_id):
"""Update cluster host."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_cluster_host(
cluster_id, host_id, user=current_user, **data
)
)
@app.route(
'/clusterhosts/<int:clusterhost_id>',
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_clusterhost(clusterhost_id):
"""Update cluster host."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost(
clusterhost_id, user=current_user, **data
)
)
@app.route(
'/clusters/<int:cluster_id>/hosts/<int:host_id>',
methods=['PATCH']
)
@log_user_action
@login_required
@update_user_token
def patch_cluster_host(cluster_id, host_id):
"""Update cluster host."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.patch_cluster_host(
cluster_id, host_id, user=current_user, **data
)
)
@app.route(
'/clusterhosts/<int:clusterhost_id>',
methods=['PATCH']
)
@log_user_action
@login_required
@update_user_token
def patch_clusterhost(clusterhost_id):
"""Update cluster host."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.patch_clusterhost(
clusterhost_id, user=current_user, **data
)
)
@app.route(
'/clusters/<int:cluster_id>/hosts/<int:host_id>',
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
def delete_cluster_host(cluster_id, host_id):
"""Delete cluster host."""
data = _get_request_data()
response = cluster_api.del_cluster_host(
cluster_id, host_id, user=current_user, **data
)
if 'status' in response:
return utils.make_json_response(
202, response
)
else:
return utils.make_json_response(
200, response
)
@app.route(
'/clusterhosts/<int:clusterhost_id>',
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
def delete_clusterhost(clusterhost_id):
"""Delete cluster host."""
data = _get_request_data()
response = cluster_api.del_clusterhost(
clusterhost_id, user=current_user, **data
)
if 'status' in response:
return utils.make_json_response(
202, response
)
else:
return utils.make_json_response(
200, response
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/config",
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_cluster_host_config(cluster_id, host_id):
"""Get clusterhost config."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_cluster_host_config(
cluster_id, host_id, user=current_user, **data
)
)
@app.route("/clusterhosts/<int:clusterhost_id>/config", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_clusterhost_config(clusterhost_id):
"""Get clusterhost config."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_clusterhost_config(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/config",
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_cluster_host_config(cluster_id, host_id):
"""update clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_cluster_host_config(
cluster_id, host_id, user=current_user, **data
)
)
@app.route("/clusterhosts/<int:clusterhost_id>/config", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_clusterhost_config(clusterhost_id):
"""update clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost_config(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/config",
methods=['PATCH']
)
@log_user_action
@login_required
@update_user_token
def patch_cluster_host_config(cluster_id, host_id):
"""patch clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.patch_cluster_host_config(
cluster_id, host_id, user=current_user, **data
)
)
@app.route("/clusterhosts/<int:clusterhost_id>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_clusterhost_config(clusterhost_id):
"""patch clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.patch_clusterhost_config(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/config",
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
def delete_cluster_host_config(cluster_id, host_id):
"""Delete clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.del_clusterhost_config(
cluster_id, host_id, user=current_user, **data
)
)
@app.route("/clusterhosts/<int:clusterhost_id>/config", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_clusterhost_config(clusterhost_id):
"""Delete clusterhost config."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.del_clusterhost_config(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/state",
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_cluster_host_state(cluster_id, host_id):
"""Get clusterhost state."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_cluster_host_state(
cluster_id, host_id, user=current_user, **data
)
)
@app.route("/clusterhosts/<int:clusterhost_id>/state", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_clusterhost_state(clusterhost_id):
"""Get clusterhost state."""
data = _get_request_args()
return utils.make_json_response(
200,
cluster_api.get_clusterhost_state(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusters/<int:cluster_id>/hosts/<int:host_id>/state",
methods=['PUT', 'POST']
)
@log_user_action
@login_required
@update_user_token
def update_cluster_host_state(cluster_id, host_id):
"""update clusterhost state."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost_state(
cluster_id, host_id, user=current_user, **data
)
)
@app.route(
"/clusters/<clustername>/hosts/<hostname>/state_internal",
methods=['PUT', 'POST']
)
def update_cluster_host_state_internal(clustername, hostname):
"""update clusterhost state."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost_state_internal(
clustername, hostname, **data
)
)
@app.route(
"/clusterhosts/<int:clusterhost_id>/state",
methods=['PUT', 'POST']
)
@log_user_action
@login_required
@update_user_token
def update_clusterhost_state(clusterhost_id):
"""update clusterhost state."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost_state(
clusterhost_id, user=current_user, **data
)
)
@app.route(
"/clusterhosts/<clusterhost_name>/state_internal",
methods=['PUT', 'POST']
)
def update_clusterhost_state_internal(clusterhost_name):
"""update clusterhost state."""
data = _get_request_data()
return utils.make_json_response(
200,
cluster_api.update_clusterhost_state_internal(
clusterhost_name, **data
)
)
@app.route("/hosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_hosts():
"""List hosts."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(host_api.list_hosts(
user=current_user, **data
))
)
@app.route("/hosts/<int:host_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_host(host_id):
"""Get host."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(host_api.get_host(
host_id, user=current_user, **data
))
)
@app.route("/machines-hosts", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_machines_or_hosts():
"""Get host."""
data = _get_request_args(os_id=_int_converter)
_filter_tag(data)
_filter_location(data)
_filter_general(data, 'os_name')
_filter_general(data, 'os_id')
return utils.make_json_response(
200,
_reformat_host(host_api.list_machines_or_hosts(
user=current_user, **data
))
)
@app.route("/machines-hosts/<int:host_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_machine_or_host(host_id):
"""Get host."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host(host_api.get_machine_or_host(
host_id, user=current_user, **data
))
)
@app.route("/hosts/<int:host_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_host(host_id):
"""update host."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_host(
host_id, user=current_user, **data
)
)
@app.route("/hosts", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_hosts():
"""update hosts."""
data = _get_request_data_as_list()
return utils.make_json_response(
200,
host_api.update_hosts(
data, user=current_user,
)
)
@app.route("/hosts/<int:host_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_host(host_id):
"""Delete host."""
data = _get_request_data()
response = host_api.del_host(
host_id, user=current_user, **data
)
if 'status' in response:
return utils.make_json_response(
202, response
)
else:
return utils.make_json_response(
200, response
)
@app.route("/hosts/<int:host_id>/clusters", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def get_host_clusters(host_id):
"""Get host clusters."""
data = _get_request_args()
return utils.make_json_response(
200,
host_api.get_host_clusters(
host_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/config", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_host_config(host_id):
"""Get host config."""
data = _get_request_args()
return utils.make_json_response(
200,
host_api.get_host_config(
host_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/config", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_host_config(host_id):
"""update host config."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_host_config(host_id, user=current_user, **data)
)
@app.route("/hosts/<int:host_id>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def patch_host_config(host_id):
"""patch host config."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.patch_host_config(host_id, user=current_user, **data)
)
@app.route("/hosts/<int:host_id>/config", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_host_config(host_id):
"""Delete host config."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.del_host_config(
host_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/networks", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_host_networks(host_id):
"""list host networks."""
data = _get_request_args()
return utils.make_json_response(
200,
_reformat_host_networks(
host_api.list_host_networks(
host_id, user=current_user, **data
)
)
)
@app.route("/host/networks", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def list_hostnetworks():
"""list host networks."""
data = _get_request_args(
is_mgmt=_bool_converter,
is_promiscuous=_bool_converter
)
return utils.make_json_response(
200,
_reformat_host_networks(
host_api.list_hostnetworks(user=current_user, **data)
)
)
@app.route(
"/hosts/<int:host_id>/networks/<int:host_network_id>",
methods=['GET']
)
@log_user_action
@login_required
@update_user_token
def show_host_network(host_id, host_network_id):
"""Get host network."""
data = _get_request_args()
return utils.make_json_response(
200,
host_api.get_host_network(
host_id, host_network_id, user=current_user, **data
)
)
@app.route("/host/networks/<int:host_network_id>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_hostnetwork(host_network_id):
"""Get host network."""
data = _get_request_args()
return utils.make_json_response(
200,
host_api.get_hostnetwork(
host_network_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/networks", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def add_host_network(host_id):
"""add host network."""
data = _get_request_data()
return utils.make_json_response(
200, host_api.add_host_network(host_id, user=current_user, **data)
)
@app.route("/hosts/networks", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_host_networks():
"""add host networks."""
data = _get_request_data_as_list()
return utils.make_json_response(
200, host_api.add_host_networks(
data, user=current_user,)
)
@app.route(
"/hosts/<int:host_id>/networks/<int:host_network_id>",
methods=['PUT']
)
@log_user_action
@login_required
@update_user_token
def update_host_network(host_id, host_network_id):
"""update host network."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_host_network(
host_id, host_network_id, user=current_user, **data
)
)
@app.route("/host-networks/<int:host_network_id>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def update_hostnetwork(host_network_id):
"""update host network."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_hostnetwork(
host_network_id, user=current_user, **data
)
)
@app.route(
"/hosts/<int:host_id>/networks/<int:host_network_id>",
methods=['DELETE']
)
@log_user_action
@login_required
@update_user_token
def delete_host_network(host_id, host_network_id):
"""Delete host network."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.del_host_network(
host_id, host_network_id, user=current_user, **data
)
)
@app.route("/host-networks/<int:host_network_id>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def delete_hostnetwork(host_network_id):
"""Delete host network."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.del_hostnetwork(
host_network_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/state", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def show_host_state(host_id):
"""Get host state."""
data = _get_request_args()
return utils.make_json_response(
200,
host_api.get_host_state(
host_id, user=current_user, **data
)
)
@app.route("/hosts/<int:host_id>/state", methods=['PUT', 'POST'])
@log_user_action
@login_required
@update_user_token
def update_host_state(host_id):
"""update host state."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_host_state(
host_id, user=current_user, **data
)
)
@app.route("/hosts/<hostname>/state_internal", methods=['PUT', 'POST'])
def update_host_state_internal(hostname):
"""update host state."""
data = _get_request_data()
return utils.make_json_response(
200,
host_api.update_host_state_internal(
hostname, **data
)
)
def _poweron_host(*args, **kwargs):
return utils.make_json_response(
202,
host_api.poweron_host(
*args, **kwargs
)
)
def _poweroff_host(*args, **kwargs):
return utils.make_json_response(
202,
host_api.poweroff_host(
*args, **kwargs
)
)
def _reset_host(*args, **kwargs):
return utils.make_json_response(
202,
host_api.reset_host(
*args, **kwargs
)
)
@app.route("/hosts/<int:host_id>/action", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def take_host_action(host_id):
"""take host action."""
data = _get_request_data()
poweron_func = _wrap_response(
functools.partial(
host_api.poweron_host, host_id, user=current_user,
),
202
)
poweroff_func = _wrap_response(
functools.partial(
host_api.poweroff_host, host_id, user=current_user,
),
202
)
reset_func = _wrap_response(
functools.partial(
host_api.reset_host, host_id, user=current_user,
)
)
return _group_data_action(
data,
poweron=poweron_func,
poweroff=poweroff_func,
reset=reset_func,
)
def _get_headers(*keys):
headers = {}
for key in keys:
if key in request.headers:
headers[key] = request.headers[key]
return headers
def _get_response_json(response):
try:
return response.json()
except ValueError:
return response.text
@app.route("/proxy/<path:url>", methods=['GET'])
@log_user_action
@login_required
@update_user_token
def proxy_get(url):
"""proxy url."""
headers = _get_headers(
'Content-Type', 'Accept-Encoding',
'Content-Encoding', 'Accept', 'User-Agent',
'Content-MD5', 'Transfer-Encoding', app.config['AUTH_HEADER_NAME'],
'Cookie'
)
response = requests.get(
'%s/%s' % (setting.PROXY_URL_PREFIX, url),
params=_get_request_args(),
headers=headers,
stream=True
)
logging.debug(
'proxy %s response: %s',
url, response.text
)
return utils.make_json_response(
response.status_code, _get_response_json(response)
)
@app.route("/proxy/<path:url>", methods=['POST'])
@log_user_action
@login_required
@update_user_token
def proxy_post(url):
"""proxy url."""
headers = _get_headers(
'Content-Type', 'Accept-Encoding',
'Content-Encoding', 'Accept', 'User-Agent',
'Content-MD5', 'Transfer-Encoding',
'Cookie'
)
response = requests.post(
'%s/%s' % (setting.PROXY_URL_PREFIX, url),
data=request.data,
headers=headers
)
logging.debug(
'proxy %s response: %s',
url, response.text
)
return utils.make_json_response(
response.status_code, _get_response_json(response)
)
@app.route("/proxy/<path:url>", methods=['PUT'])
@log_user_action
@login_required
@update_user_token
def proxy_put(url):
"""proxy url."""
headers = _get_headers(
'Content-Type', 'Accept-Encoding',
'Content-Encoding', 'Accept', 'User-Agent',
'Content-MD5', 'Transfer-Encoding',
'Cookie'
)
response = requests.put(
'%s/%s' % (setting.PROXY_URL_PREFIX, url),
data=request.data,
headers=headers
)
logging.debug(
'proxy %s response: %s',
url, response.text
)
return utils.make_json_response(
response.status_code, _get_response_json(response)
)
@app.route("/proxy/<path:url>", methods=['PATCH'])
@log_user_action
@login_required
@update_user_token
def proxy_patch(url):
"""proxy url."""
headers = _get_headers(
'Content-Type', 'Accept-Encoding',
'Content-Encoding', 'Accept', 'User-Agent',
'Content-MD5', 'Transfer-Encoding',
'Cookie'
)
response = requests.patch(
'%s/%s' % (setting.PROXY_URL_PREFIX, url),
data=request.data,
headers=headers
)
logging.debug(
'proxy %s response: %s',
url, response.text
)
return utils.make_json_response(
response.status_code, _get_response_json(response)
)
@app.route("/proxy/<path:url>", methods=['DELETE'])
@log_user_action
@login_required
@update_user_token
def proxy_delete(url):
"""proxy url."""
headers = _get_headers(
'Content-Type', 'Accept-Encoding',
'Content-Encoding', 'Accept', 'User-Agent',
'Content-MD5', 'Transfer-Encoding',
'Cookie'
)
response = requests.delete(
'%s/%s' % (setting.PROXY_URL_PREFIX, url),
headers=headers
)
logging.debug(
'proxy %s response: %s',
url, response.text
)
return utils.make_json_response(
response.status_code, _get_response_json(response)
)
def init():
logging.info('init flask')
database.init()
adapter_api.load_adapters()
metadata_api.load_metadatas()
if __name__ == '__main__':
flags.init()
logsetting.init()
init()
app.run(host='0.0.0.0')
View Git Blame Copy Permalink