class AuthCollection(Resource):
def __init__(self, api=None, *args, **kwargs):
super(AuthCollection, self).__init__(api, args, kwargs)
self.auth = AuthController()
@api.expect(auth_serializer)
def post(self):
data = request.json
email = data.get('email')
password = data.get('password')
user = self.auth.login(email=email, password=password)
if user:
token = self.auth.generate_auth_token(id_user=user.id)
if token:
self.auth.save_token(token=token.decode(), id_user=user.id)
response = {
"status": "success",
"message": "Logged successfuly",
"X-API-KEY": token.decode()
}
return response, 200
else:
response = {"status": "fail", "message": "Users does not exists"}
return response, 404
def decorated(*args, **kwargs):
token = request.headers.get("X-API-KEY")
data, status = AuthController.auth_token_is_valid(token=token)
auth_token = data.get('data')
if not auth_token:
return data, status
return f(*args, **kwargs)
from flask import request
from app.controllers.auth_controller import AuthController
from library.engine.utils import json_response, cursor_to_list
from library.engine.cache import cached_function
EXECUTER_DATA_CACHE_TIMEOUT = 300 # 5 minutes
open_ctrl = AuthController("open", __name__, require_auth=False)
@cached_function(positive_only=True, cache_timeout=EXECUTER_DATA_CACHE_TIMEOUT)
def get_executer_data(query, recursive=False, include_unattached=False):
from app.models import Project, Datacenter, Group, Host
host_fields = list(Host.FIELDS)
group_fields = list(Group.FIELDS)
if recursive:
host_fields += ["all_tags", "all_custom_fields"]
group_fields += ["all_tags", "all_custom_fields"]
projects = Project.find(query)
projects = cursor_to_list(projects)
project_ids = [x["_id"] for x in projects]
groups = Group.find({"project_id": {"$in": project_ids}})
groups = cursor_to_list(groups, fields=group_fields)
group_ids = [x["_id"] for x in groups]
if include_unattached:
hosts = Host.find({})
from app.controllers.auth_controller import AuthController
from library.engine.utils import resolve_id, json_response, paginated_data, json_exception
from flask import request
datacenters_ctrl = AuthController("datacenters", __name__, require_auth=True)
def _get_dc_by_id(dc_id):
from app.models import Datacenter
dc_id = resolve_id(dc_id)
return Datacenter.find_one({"$or": [{"_id": dc_id}, {"name": dc_id}]})
@datacenters_ctrl.route("/", methods=["GET"])
@datacenters_ctrl.route("/<datacenter_id>", methods=["GET"])
def show(datacenter_id=None):
from app.models import Datacenter
if datacenter_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) >= 2:
query["name"] = {"$regex": "^%s" % name_filter}
datacenters = Datacenter.find(query)
else:
datacenter_id = resolve_id(datacenter_id)
datacenters = Datacenter.find(
{"$or": [{
"_id": datacenter_id
}, {
"name": datacenter_id
from flask import request
from bson.objectid import ObjectId, InvalidId
from app.controllers.auth_controller import AuthController
from library.engine.utils import resolve_id, json_response, json_exception, paginated_data, diff
groups_ctrl = AuthController("groups", __name__, require_auth=True)
def _get_group_by_id(group_id):
from app.models import Group
group_id = resolve_id(group_id)
return Group.find_one({
"$or": [
{ "_id": group_id },
{ "name": group_id }
]
})
@groups_ctrl.route("/")
@groups_ctrl.route("/<group_id>")
def show(group_id=None):
from app.models import Group
if group_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) >= 2:
query["name"] = { "$regex": "^%s" % name_filter }
if "project_id" in request.values:
project_id = resolve_id(request.values["project_id"])
def update_user(user_id):
data = request.get_json()
controller = AuthController()
controller.update(user_id, data)
return jsonify(controller.content), controller.status
def signup():
return AuthController().signup()
from app.controllers.auth_controller import AuthController
from flask import request, g
from library.engine.utils import json_response, resolve_id, paginated_data, json_exception
users_ctrl = AuthController("users", __name__, require_auth=True)
@users_ctrl.route("/")
@users_ctrl.route("/<user_id>")
def show(user_id=None):
from app.models import User
if user_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) >= 2:
query["username"] = { "$regex": "^%s" % name_filter }
users = User.find(query)
else:
user_id = resolve_id(user_id)
users = User.find({
"$or": [
{ "_id": user_id },
{ "username": user_id }
]
})
if users.count() == 0:
return json_response({"errors":["User not found"]}, 404)
try:
data = paginated_data(users.sort("username"))
except AttributeError as e:
def create_user (): data = request.get_json() ip_address = request.remote_addr controller = AuthController() controller.login(data, ip_address) return jsonify(controller.content), controller.status
def __init__(self, api=None, *args, **kwargs):
super(AuthCollection, self).__init__(api, args, kwargs)
self.auth = AuthController()
from flask import request, g
from app.controllers.auth_controller import AuthController
from library.engine.utils import resolve_id, paginated_data, \
json_response, clear_aux_fields, json_exception
projects_ctrl = AuthController("projects", __name__, require_auth=True)
@projects_ctrl.route("/", methods=["GET"])
@projects_ctrl.route("/<project_id>", methods=["GET"])
def show(project_id=None):
"list/show handler for projects"
from app.models import Project
if project_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) > 2:
query["name"] = { "$regex": "^%s" % name_filter }
projects = Project.find(query)
else:
project_id = resolve_id(project_id)
projects = Project.find({ "$or": [
{ "_id": project_id },
{ "name": project_id }
] })
return json_response(paginated_data(projects.sort("name")))
@projects_ctrl.route("/", methods=["POST"])
def create():
from app.models import Project
data = clear_aux_fields(request.json)
def logout():
return AuthController(Context(app.logger)).logout(request)
def signup():
return AuthController(Context(app.logger)).signup(request)
def delete_user(user_id):
controller = AuthController()
controller.remove(user_id)
return jsonify(controller.content), controller.status
# Tag $puppet_class:<class_name> adds specified class
# Tag $puppet_param:<param_key>=<param_value> adds classifier parameter
# Tag $puppet_env:<environment_name> adds classifier environment
#
# All tags are processed sequentally in random order, having several parameters
# with the same key results in undefined behaviour: you'll never be sure what
# exact value is used
#
import re
import yaml
from flask import make_response
from library.engine.utils import resolve_id, json_response, paginated_data, json_exception
from app.controllers.auth_controller import AuthController
puppet_ctrl = AuthController("puppet", __name__, require_auth=False)
CLASS_EXPR = re.compile(r"^\$puppet_class:(.+)$")
PARAM_EXPR = re.compile(r"^\$puppet_param:([^=]+)=(.+)$")
ENV_EXPR = re.compile(r"^$puppet_env:(.+)$")
def yaml_response(data):
yaml_data = yaml.safe_dump(data, default_flow_style=False)
return make_response(yaml_data, 200, {"Content-Type": "application/yaml"})
@puppet_ctrl.route("/enc/<host_id>", methods=["GET"])
def enc(host_id):
from app.models import Host
host_id = resolve_id(host_id)
def get_user (user_id): controller = AuthController() ip_address = request.remote_addr controller.get(user_id) return jsonify(controller.content), controller.status
from app.controllers.auth_controller import AuthController
from flask import session, request, g
from library.engine.utils import json_response
account_ctrl = AuthController("auth", __name__, require_auth=False)
@account_ctrl.route("/me", methods=["GET"])
def me():
if g.user is None:
return json_response(
{
"errors": ["You must be authenticated first"],
"state": "logged out"
}, 403)
else:
user_data = g.user.to_dict()
user_data["auth_token"] = g.user.get_auth_token().token
return json_response({"data": user_data})
@account_ctrl.route("/authenticate", methods=["POST"])
def authenticate():
if g.user:
user_data = g.user.to_dict()
if "password_hash" in user_data:
del (user_data["password_hash"])
return json_response({"status": "authenticated", "data": user_data})
from app.models import User
data = request.json
if data is None:
from app.blueprints.base_blueprint import Blueprint, BaseBlueprint, request, Security, Auth
from app.controllers.auth_controller import AuthController
url_prefix = '{}/auth'.format(BaseBlueprint.base_url_prefix)
auth_blueprint = Blueprint('auth', __name__, url_prefix=url_prefix)
auth_controller = AuthController(request)
@auth_blueprint.route('/login', methods=['POST'])
@Security.validator(['email|required', 'password|required'])
def login():
return auth_controller.login()
@auth_blueprint.route('/admin/login', methods=['POST'])
@Security.validator(['email|required', 'password|required'])
def admin_login():
return auth_controller.login(admin=True)
def login():
return AuthController().login()
from app.controllers.auth_controller import AuthController
from library.engine.utils import resolve_id, json_response, paginated_data
from flask import request
hosts_ctrl = AuthController('hosts', __name__, require_auth=True)
@hosts_ctrl.route("/", methods=["GET"])
@hosts_ctrl.route("/<host_id>", methods=["GET"])
def show(host_id=None):
from app.models import Host
if host_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) >= 2:
query["fqdn"] = { "$regex": "^%s" % name_filter }
hosts = Host.find(query)
else:
host_id = resolve_id(host_id)
hosts = Host.find({ "$or": [
{ "_id": host_id },
{ "fqdn": host_id },
{ "short_name": host_id }
]})
data = paginated_data(hosts.sort("fqdn"))
return json_response(data)
def logout():
return AuthController().logout()
def create_user():
data = request.get_json()
controller = AuthController()
controller.save(data)
return jsonify(controller.content), controller.status
