async def login_post(request):
"""Evaluate the submitted login information. Redirects to index page if login information valid, otherwise back to login.
On the first login, the user will be directed to the settings page and asked to change the password."""
try:
users.read_users()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
form = dict(await request.form())
if users.evaluate_password(form.get("username", ""), form.get("password", "")):
request.session.update({"user": form["username"]})
if users.is_admin(form["username"]) == True:
request.session.update({"is_admin": "Jawohl"})
monitor.send_webgui_event(monitor.w_events.LOGIN, form["username"], "{admin}".format(admin="ADMIN" if users.is_admin(form["username"]) else ""))
if users.needs_change_password(form["username"]):
return RedirectResponse(url="/settings", status_code=303)
else:
return RedirectResponse(url="/", status_code=303)
else:
if request.client.host is None:
source_ip = "UNKOWN IP"
else:
source_ip = request.client.host
monitor.send_webgui_event(monitor.w_events.LOGIN_FAIL, form["username"], source_ip)
template = "login.html"
context = {"request": request, "invalid_password": 1, "mercure_version": mercure_defs.VERSION, "appliance_name": config.mercure.get("appliance_name", "mercure Router")}
return templates.TemplateResponse(template, context)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION}
return templates.TemplateResponse(template, context, status_code=500)
async def settings_edit(request):
"""Shows the settings for the current user. Renders the same template as the normal user edit, but with parameter own_settings=True."""
try:
users.read_users()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
own_name = request.user.display_name
template = "users_edit.html"
context = {
"request":
request,
"mercure_version":
mercure_defs.VERSION,
"page":
"settings",
"edituser":
own_name,
"edituser_info":
users.users_list[own_name],
"own_settings":
"True",
"change_password":
users.users_list[own_name].get("change_password", "False")
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def configuration_edit(request):
"""Shows a configuration editor"""
# Check for existence of lock file
cfg_file = Path(config.configuration_filename)
cfg_lock = Path(cfg_file.parent / cfg_file.stem).with_suffix(
mercure_names.LOCK)
if cfg_lock.exists():
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
try:
with open(cfg_file, "r") as json_file:
config_content = json.load(json_file)
except:
return PlainTextResponse('Error reading configuration file.')
config_content = json.dumps(config_content, indent=4, sort_keys=False)
template = "configuration_edit.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "configuration",
"config_content": config_content
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def show_modules(request):
"""Shows all installed modules"""
try:
config.read_config()
except:
return PlainTextResponse(
"Configuration is being updated. Try again in a minute.")
used_modules = {}
for rule in config.mercure["rules"]:
used_module = config.mercure["rules"][rule].get(
"processing_module", "NONE")
used_modules[used_module] = rule
template = "modules.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "modules",
"modules": config.mercure["modules"],
"used_modules": used_modules
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "404.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION}
return templates.TemplateResponse(template, context, status_code=404)
async def show_queues(request):
"""Shows all installed modules"""
try:
config.read_config()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
processing_suspended = False
processing_halt_file = Path(config.mercure['processing_folder'] + '/' +
mercure_names.HALT)
if processing_halt_file.exists():
processing_suspended = True
routing_suspended = False
routing_halt_file = Path(config.mercure['outgoing_folder'] + '/' +
mercure_names.HALT)
if routing_halt_file.exists():
routing_suspended = True
template = "queue.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "queue",
"processing_suspended": processing_suspended,
"routing_suspended": routing_suspended
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def login(request):
"""Shows the login page."""
try:
config.read_config()
except:
return PlainTextResponse("Error reading configuration file.")
request.session.clear()
template = "login.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "appliance_name": config.mercure.get("appliance_name", "master")}
return templates.TemplateResponse(template, context)
async def show_users(request):
"""Shows all available users."""
try:
users.read_users()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
template = "users.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "page": "users", "users": users.users_list}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def show_rules(request):
"""Show all defined routing rules. Can be executed by all logged-in users."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
template = "rules.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "page": "rules", "rules": config.mercure["rules"]}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def homepage(request):
"""Renders the index page that shows information about the system status."""
used_space = 0
free_space = 0
total_space = 0
try:
disk_total, disk_used, disk_free = shutil.disk_usage(
config.mercure["incoming_folder"])
if (disk_total == 0):
disk_total = 1
used_space = 100 * disk_used / disk_total
free_space = (disk_free // (2**30))
total_space = (disk_total // (2**30))
except:
used_space = -1
free_space = "N/A"
disk_total = "N/A"
service_status = {}
for service in services.services_list:
running_status = "False"
if (services.services_list[service].get("systemd_service", "")):
if (await async_run("systemctl is-active " +
services.services_list[service]
["systemd_service"]))[0] == 0:
running_status = "True"
service_status[service] = {
"id": service,
"name": services.services_list[service]["name"],
"running": running_status
}
template = "index.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "homepage",
"used_space": used_space,
"free_space": free_space,
"total_space": total_space,
"service_status": service_status
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def show_targets(request):
"""Shows all configured targets."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
used_targets = {}
for rule in config.mercure["rules"]:
used_target = config.mercure["rules"][rule].get("target", "NONE")
used_targets[used_target] = rule
template = "targets.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "page": "targets", "targets": config.mercure["targets"], "used_targets": used_targets}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def users_edit(request):
"""Shows the settings for a given user."""
try:
users.read_users()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
edituser = request.path_params["user"]
if not edituser in users.users_list:
return RedirectResponse(url="/users", status_code=303)
template = "users_edit.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "page": "users", "edituser": edituser, "edituser_info": users.users_list[edituser]}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def targets_edit(request):
"""Shows the edit page for the given target."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
edittarget = request.path_params["target"]
if not edittarget in config.mercure["targets"]:
return RedirectResponse(url="/targets", status_code=303)
template = "targets_edit.html"
context = {"request": request, "mercure_version": mercure_defs.VERSION, "page": "targets", "targets": config.mercure["targets"], "edittarget": edittarget}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def edit_module(request):
"""Shows all installed modules"""
module = request.path_params["module"]
try:
config.read_config()
except:
return PlainTextResponse(
"Configuration is being updated. Try again in a minute.")
template = "modules_edit.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "modules",
"module": config.mercure["modules"][module],
"module_name": module
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def configuration(request):
"""Shows the current configuration of the mercure appliance."""
try:
config.read_config()
except:
return PlainTextResponse('Error reading configuration file.')
template = "configuration.html"
config_edited = int(request.query_params.get("edited", 0))
os_info = distro.linux_distribution()
os_string = f"{os_info[0]} Version {os_info[1]} ({os_info[2]})"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "configuration",
"config": config.mercure,
"os_string": os_string,
"config_edited": config_edited
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def rules_edit(request):
"""Shows the edit page for the given routing rule."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
rule = request.path_params["rule"]
template = "rules_edit.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "rules",
"rules": config.mercure["rules"],
"targets": config.mercure["targets"],
"modules": config.mercure["modules"],
"rule": rule,
"alltags": tagslist.alltags,
"sortedtags": tagslist.sortedtags,
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def show_log(request):
"""Render the log for the given service. The time range can be specified via URL parameters."""
requested_service = request.path_params["service"]
# Get optional start and end dates from the URL. Make sure
# that the date format is clean
try:
start_date = request.query_params.get("from", "")
start_time = request.query_params.get("from_time", "")
datetime.datetime.strptime(start_date, '%Y-%m-%d')
start_date_cmd = ' --since "' + start_date
if start_date and start_time:
datetime.datetime.strptime(start_time, '%H:%M')
start_date_cmd = start_date_cmd + " " + start_time
start_date_cmd = start_date_cmd + '"'
except:
start_date = ""
start_time = ""
start_date_cmd = ""
try:
end_date = request.query_params.get("to", "")
end_time = request.query_params.get("to_time", "")
datetime.datetime.strptime(end_date, '%Y-%m-%d')
end_date_cmd = ' --until "' + end_date
if end_date and end_time:
datetime.datetime.strptime(end_time, '%H:%M')
end_date_cmd = end_date_cmd + " " + end_time
end_date_cmd = end_date_cmd + '"'
except:
end_date = ""
end_time = ""
end_date_cmd = ""
service_logs = {}
for service in services.services_list:
service_logs[service] = {
"id": service,
"name": services.services_list[service]["name"],
"systemd": services.services_list[service]["systemd_service"]
}
if (not requested_service in service_logs) or (
not services.services_list[requested_service]["systemd_service"]):
return PlainTextResponse(
'Service does not exist or is incorrectly configured.')
run_result = await async_run(
'journalctl -n 1000 -u ' +
services.services_list[requested_service]["systemd_service"] +
start_date_cmd + end_date_cmd)
log_content = ""
if run_result[0] == 0:
log_content = html.escape(str(run_result[1].decode()))
line_list = log_content.split('\n')
if len(line_list) and (not line_list[-1]):
del line_list[-1]
log_content = '<br />'.join(line_list)
else:
log_content = "Error reading log information."
if start_date or end_date:
log_content = log_content + "<br /><br />Are the From/To settings valid?"
template = "logs.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "logs",
"service_logs": service_logs,
"log_id": requested_service,
"log_content": log_content,
"start_date": start_date,
"start_time": start_time,
"end_date": end_date,
"end_time": end_time
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def homepage(request):
"""Renders the index page that shows information about the system status."""
used_space = 0
free_space = 0
total_space = 0
try:
disk_total, disk_used, disk_free = shutil.disk_usage(
config.mercure["incoming_folder"])
if disk_total == 0:
disk_total = 1
used_space = 100 * disk_used / disk_total
free_space = disk_free // (2**30)
total_space = disk_total // (2**30)
except:
used_space = -1
free_space = "N/A"
disk_total = "N/A"
service_status = {}
for service in services.services_list:
running_status = "False"
if services.services_list[service].get("systemd_service", ""):
if (await async_run("systemctl is-active " +
services.services_list[service]
["systemd_service"]))[0] == 0:
running_status = "True"
elif services.services_list[service].get("docker_service", ""):
client = docker.from_env()
try:
container = client.containers.get(
services.services_list[service]["docker_service"])
container.reload()
status = container.status
"""restarting, running, paused, exited"""
if status == "running":
running_status = "True"
except (docker.errors.NotFound, docker.errors.APIError):
running_status = "False"
service_status[service] = {
"id": service,
"name": services.services_list[service]["name"],
"running": running_status
}
template = "index.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "homepage",
"used_space": used_space,
"free_space": free_space,
"total_space": total_space,
"service_status": service_status,
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
async def show_log(request):
"""Render the log for the given service. The time range can be specified via URL parameters."""
requested_service = request.path_params["service"]
# Get optional start and end dates from the URL. Make sure
# that the date format is clean.
try:
start_date = request.query_params.get("from", "")
start_time = request.query_params.get("from_time", "00:00")
start_timestamp = f"{start_date} {start_time}"
start_obj = datetime.datetime.strptime(start_timestamp,
"%Y-%m-%d %H:%M")
except ValueError:
start_obj = None
start_timestamp = ""
try:
end_date = request.query_params.get("to", "")
# Make sure end time includes the day-of, unless otherwise specified
end_time = request.query_params.get("to_time", "23:59")
end_timestamp = f"{end_date} {end_time}"
datetime.datetime.strptime(end_timestamp, "%Y-%m-%d %H:%M")
except ValueError:
end_timestamp = ""
service_logs = {}
for service in services.services_list:
service_logs[service] = {
"id": service,
"name": services.services_list[service]["name"],
"systemd":
services.services_list[service].get("systemd_service", ""),
"docker":
services.services_list[service].get("docker_service", "")
}
if requested_service not in service_logs:
return PlainTextResponse("Service does not exist.")
if "systemd_service" not in services.services_list[requested_service] and \
"docker_service" not in services.services_list[requested_service]:
return PlainTextResponse("Service incorrectly configured.")
return_code = -1
raw_logs = ""
if "systemd_service" in services.services_list[requested_service]:
start_date_cmd = ""
end_date_cmd = ""
if start_timestamp:
start_date_cmd = f'--since {start_timestamp}'
if end_timestamp:
end_date_cmd = f'--until {end_timestamp}'
run_result = await async_run(
f'journalctl -n 1000 -u '
f'{services.services_list[requested_service]["systemd_service"]} '
f'{start_date_cmd} {end_date_cmd}')
return_code = run_result[0]
raw_logs = run_result[1]
elif "docker_service" in services.services_list[requested_service]:
client = docker.from_env()
try:
container = client.containers.get(
services.services_list[requested_service]["docker_service"])
container.reload()
raw_logs = container.logs(since=start_obj)
return_code = 0
except (docker.errors.NotFound, docker.errors.APIError):
return_code = 1
if return_code == 0:
log_content = html.escape(str(raw_logs.decode()))
line_list = log_content.split("\n")
if len(line_list) and (not line_list[-1]):
del line_list[-1]
log_content = "<br />".join(line_list)
else:
log_content = "Error reading log information."
if start_date or end_date:
log_content = log_content + "<br /><br />Are the From/To settings valid?"
template = "logs.html"
context = {
"request": request,
"mercure_version": mercure_defs.VERSION,
"page": "logs",
"service_logs": service_logs,
"log_id": requested_service,
"log_content": log_content,
"start_date": start_date,
"start_time": start_time,
"end_date": end_date,
"end_time": end_time,
}
context.update(get_user_information(request))
return templates.TemplateResponse(template, context)
