class IncidentUpdatesNotify(View):
__request = None
__response = None
__helpers = None
__form = None
__logger = None
__user_id = None
__incident_update = None
__task = None
__notification = None
__subscriber = None
__correlation_id = None
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__incident_update = IncidentUpdateModule()
self.__task = Task_Module()
self.__notification = NotificationModule()
self.__subscriber = SubscriberModule()
self.__logger = self.__helpers.get_logger(__name__)
self.__form.add_validator(ExtraRules())
@allow_if_authenticated
def post(self, request, incident_id, update_id):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
task = self.__task.delay("incident_update", {
"incident_update_id": update_id,
"user_id": self.__user_id
}, self.__user_id)
result = False
if task:
result = self.__notification.create_notification({
"highlight": "Incident Update",
"notification": "notifying subscribers with the incident update",
"url": "#",
"type": NotificationModule.PENDING,
"delivered": False,
"user_id": self.__user_id,
"task_id": task.id
})
if task and result:
return JsonResponse(self.__response.send_private_success([{
"type": "success",
"message": _("Notification delivery started successfully.")
}], {}, self.__correlation_id))
else:
return JsonResponse(self.__response.send_private_failure([{
"type": "error",
"message": _("Error! Something goes wrong while starting delivery.")
}], {}, self.__correlation_id))
class Errors():
def __init__(self, get_response):
self.__helpers = Helpers()
self.get_response = get_response
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
response = self.get_response(request)
return response
def process_exception(self, request, exception):
correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__logger.error(
_("The server encountered something unexpected! %(method)s:%(path)s - %(name)s - %(exception)s {'correlationId':'%(correlationId)s'}") % {
"method": request.method,
"path": request.path,
"name": exception.__class__.__name__,
"exception": exception,
"correlationId": correlation_id
}
)
self.__logger.exception(exception)
if request.is_ajax():
response = Response()
return JsonResponse(response.send_private_failure([{
"type": "error",
"message": _("Something goes wrong! Please contact a system administrator.")
}], {}, correlation_id))
return None
class Request():
def __init__(self, request=None):
self.__request = request
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def set_request(self, request):
self.__request = request
def get_request_data(self, method, predicted):
request_data = {}
log_data = {}
correlation_id = self.__request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in self.__request.META else ""
data_bag = self.__request.POST if method.lower(
) == "post" else self.__request.GET
for key, default in predicted.items():
if "password" in key:
log_data[key] = "<hidden>" if key in data_bag else default
elif "token" in key:
log_data[key] = "<hidden>" if key in data_bag else default
else:
log_data[key] = data_bag[key] if key in data_bag else default
request_data[key] = data_bag[key] if key in data_bag else default
self.__logger.debug(
_("App Incoming Request: %(data)s {'correlationId':'%(correlationId)s'}"
) % {
"data": self.__helpers.json_dumps(log_data),
"correlationId": correlation_id
})
return request_data
class Request():
__request = None
__helpers = None
__logger = None
def __init__(self, request=None):
self.__request = request
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def set_request(self, request):
self.__request = request
def get_request_data(self, method, predicted):
request_data = {}
data_bag = self.__request.POST if method.lower(
) == "post" else self.__request.GET
for key, default in predicted.items():
request_data[key] = data_bag[key] if key in data_bag else default
self.__logger.debug(
_("App Incoming Request: ") +
self.__helpers.json_dumps(request_data))
return request_data
class IncidentUpdatesComponent(View):
"""Remove Component from Incident Update Private Endpoint Controller"""
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__incident_update_component = IncidentUpdateComponentModule()
self.__logger = self.__helpers.get_logger(__name__)
self.__user_id = None
self.__correlation_id = ""
self.__form.add_validator(ExtraRules())
@allow_if_authenticated
def delete(self, request, incident_id, update_id, item_id):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
if self.__incident_update_component.delete_one_by_id(item_id):
return JsonResponse(self.__response.send_private_success([{
"type": "success",
"message": _("Affected component deleted successfully.")
}], {}, self.__correlation_id))
else:
return JsonResponse(self.__response.send_private_failure([{
"type": "error",
"message": _("Error! Something goes wrong while deleting affected component.")
}], {}, self.__correlation_id))
def wrap(controller, request, *args, **kwargs):
_helper = Helpers()
_logger = _helper.get_logger(__name__)
_logger.debug(_("Request Method: %s") % request.method)
_logger.debug(_("Request URL: %s") % request.path)
_logger.debug(_("Request Body: %s") % request.body)
return function(controller, request, *args, **kwargs)
def handler404(request, exception=None, template_name='templates/404.html'):
"""404 Error Page Controller"""
correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
helpers = Helpers()
logger = helpers.get_logger(__name__)
if exception is not None:
logger.debug(
"Route Not Found: %(exception)s {'correlationId':'%(correlationId)s'}"
% {
"exception": exception,
"correlationId": correlation_id
})
template_name = 'templates/404.html'
context = Context()
context.autoload_options()
context.push({
"page_title":
_("404 · %s") %
context.get("app_name", os.getenv("APP_NAME", "Silverback"))
})
return render(request, template_name, context.get(), status=404)
class Request():
def __init__(self, request=None):
self.__request = request
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def set_request(self, request):
self.__request = request
def get_request_data(self, method, predicted):
request_data = {}
log_data = {}
data_bag = self.__request.POST if method.lower() == "post" else self.__request.GET
for key, default in predicted.items():
if "password" in key:
log_data[key] = "<hidden>" if key in data_bag else default
elif "token" in key:
log_data[key] = "<hidden>" if key in data_bag else default
else:
log_data[key] = data_bag[key] if key in data_bag else default
request_data[key] = data_bag[key] if key in data_bag else default
self.__logger.info(_("Required request data: %(data)s") % {
"data": self.__helpers.json_dumps(log_data)
})
return request_data
class HealthCheck(View, Controller):
"""Health Check Page Controller"""
def get(self, request):
self.__health = Health()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
status = Health.OK
errors = []
errors.extend(self.__health.check_db())
errors.extend(self.__health.check_io())
errors.extend(self.__health.check_workers())
if len(errors) > 0:
status = Health.NOT_OK
self.__logger.error(
_("Health Check Result: %(status)s %(errors)s") % {
"status": status,
"errors": self.__helpers.json_dumps(errors)
})
else:
self.__logger.info(
_("Health Check Result: %(status)s %(errors)s") % {
"status": status,
"errors": self.__helpers.json_dumps(errors)
})
return JsonResponse({
"status": status,
"messages": []
},
status=200 if status == Health.OK else 503)
class Funnel():
__helpers = None
__logger = None
__rules = {}
__request = {}
def __init__(self):
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def set_rules(self, rules):
self.__rules = rules
def set_request(self, request):
self.__request = request
def action_needed(self):
return False
def fire(self):
pass
def _parse(self):
# __route_name = request.resolver_match.url_name
# if request.user and request.user.is_authenticated:
# self.__is_auth = True
# self.__user_id = request.user.id
# self.__username = request.user
pass
class Errors():
__helpers = None
__logger = None
def __init__(self, get_response):
self.__helpers = Helpers()
self.get_response = get_response
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
response = self.get_response(request)
return response
def process_exception(self, request, exception):
self.__logger.error(
_("The server encountered something unexpected! %s %s - %s - %s") % (
request.method,
request.path,
exception.__class__.__name__,
exception
)
)
if request.is_ajax():
response = Response()
return JsonResponse(response.send_private_failure([{
"type": "error",
"message": _("Something goes wrong! Please contact a system administrator.")
}]))
return None
def handler500(request, exception=None, template_name='templates/500.html'):
correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
helpers = Helpers()
logger = helpers.get_logger(__name__)
if exception is not None:
logger.error(
"Server Error: %(exception)s {'correlationId':'%(correlationId)s'}"
% {
"exception": exception,
"correlationId": correlation_id
})
template_name = 'templates/500.html'
context = Context()
context.autoload_options()
context.push({
"page_title":
_("500 · %s") %
context.get("app_name", os.getenv("APP_NAME", "Silverback"))
})
return render(request, template_name, context.get(), status=500)
class LatestNotifications(View):
__request = None
__response = None
__helpers = None
__form = None
__logger = None
__user_id = None
__notification = None
__correlation_id = None
def __init__(self):
self.__helpers = Helpers()
self.__form = Form()
self.__logger = self.__helpers.get_logger(__name__)
self.__response = Response()
self.__request = Request()
self.__notification = NotificationModule()
self.__form.add_validator(ExtraRules())
@allow_if_authenticated
def get(self, request):
self.__correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
return JsonResponse(
self.__response.send_private_success(
[],
self.__notification.user_latest_notifications(self.__user_id),
self.__correlation_id))
@allow_if_authenticated
def post(self, request):
self.__correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
self.__request.set_request(request)
request_data = self.__request.get_request_data("post",
{"notification_id": ""})
try:
notification_id = int(request_data["notification_id"])
except Exception:
return JsonResponse(
self.__response.send_private_success([], {},
self.__correlation_id))
self.__notification.mark_notification(self.__user_id, notification_id)
return JsonResponse(
self.__response.send_private_success([], {},
self.__correlation_id))
class Logging():
__helpers = None
__logger = None
def __init__(self, get_response):
self.__helpers = Helpers()
self.get_response = get_response
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__logger.debug(
_("Request Method: %(method)s {'correlationId':'%(correlationId)s'}"
) % {
"method": request.method,
"correlationId": correlation_id
})
self.__logger.debug(
_("Request URL: %(path)s {'correlationId':'%(correlationId)s'}") %
{
"path": request.path,
"correlationId": correlation_id
})
self.__logger.debug(
_("Request Body: %(body)s {'correlationId':'%(correlationId)s'}") %
{
"body": self.__hide_secure_values(request.body),
"correlationId": correlation_id
})
response = self.get_response(request)
return response
def __hide_secure_values(self, request_body):
filtered_body = []
request_body = str(request_body)
if len(request_body) == 0:
return "&".join(filtered_body)
if "&" in request_body:
request_body = request_body.split("&")
for item in request_body:
if "=" in item:
item = item.split("=")
if "password" in item[0]:
item[1] = "<hidden>"
if "token" in item[0]:
item[1] = "<hidden>"
filtered_body.append("%s=%s" % (item[0], item[1]))
return "&".join(filtered_body)
class Response():
__private = {}
__public = {}
__helpers = None
__logger = None
def __init__(self):
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def send_private_success(self, messages, payload={}):
self.__private["status"] = "success"
self.__private["messages"] = messages
if len(payload) > 0:
self.__private["payload"] = payload
self.__logger.debug(
_("App Response: ") + self.__helpers.json_dumps(self.__private) +
"\n")
return self.__private
def send_private_failure(self, messages, payload={}):
self.__private["status"] = "failure"
self.__private["messages"] = messages
if len(payload) > 0:
self.__private["payload"] = payload
self.__logger.debug(
_("App Response: ") + self.__helpers.json_dumps(self.__private) +
"\n")
return self.__private
def send_public_success(self, messages, payload={}):
self.__public["status"] = "success"
self.__public["messages"] = messages
if len(payload) > 0:
self.__public["payload"] = payload
self.__logger.debug(
_("App Response: ") + self.__helpers.json_dumps(self.__public) +
"\n")
return self.__public
def send_public_failure(self, messages, payload={}):
self.__public["status"] = "failure"
self.__public["messages"] = messages
if len(payload) > 0:
self.__public["payload"] = payload
self.__logger.debug(
_("App Response: ") + self.__helpers.json_dumps(self.__public) +
"\n")
return self.__public
class Activities(View):
"""List Activities Private Endpoint Controller"""
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__activity = ActivityModule()
self.__logger = self.__helpers.get_logger(__name__)
self.__user_id = None
self.__correlation_id = ""
self.__form.add_validator(ExtraRules())
@allow_if_authenticated
def get(self, request):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__user_id = request.user.id
self.__request.set_request(request)
request_data = self.__request.get_request_data("get", {
"offset": 0,
"limit": 20
})
try:
offset = int(request_data["offset"])
limit = int(request_data["limit"])
except Exception:
offset = 0
limit = 20
return JsonResponse(self.__response.send_private_success([], {
'activities': self.__format_activities(self.__activity.get(self.__user_id, offset, limit)),
'metadata': {
'offset': offset,
'limit': limit,
'count': self.__activity.count(self.__user_id)
}
}, self.__correlation_id))
def __format_activities(self, activities):
activities_list = []
for activity in activities:
activities_list.append({
"id": activity.id,
"activity": activity.activity,
"created_at": activity.created_at.strftime("%b %d %Y %H:%M:%S")
})
return activities_list
class Task():
def __init__(self):
self.__task_entity = TaskEntity()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def get_task_with_uuid(self, uuid):
return self.__task_entity.get_one_by_uuid(uuid)
def update_task_with_uuid(self, uuid, task):
return self.__task_entity.update_one_by_uuid(uuid, task)
def create_task(self, task):
return self.__task_entity.insert_one(task)
def delay(self, task_name, parameters, user_id):
tasks_module = importlib.import_module("app.tasks")
task_object = getattr(tasks_module, task_name)
try:
task_result = task_object.delay(**parameters)
if task_result.task_id != "":
return self.create_task({
"uuid": task_result.task_id,
"status": "pending",
"executor": task_object.name,
"parameters": json.dumps(parameters),
"result": '{}',
"user_id": user_id
})
except Exception as e:
self.__logger.error(
_("Error while sending task %(taskName)s with parameters %(parameters)s to workers: %(error)s {'correlationId':'%(correlationId)s'}"
) % {
"taskName":
task_name,
"parameters":
json.dumps(parameters),
"error":
str(e),
"correlationId":
parameters["correlation_id"]
if "correlation_id" in parameters.keys() else ""
})
return False
def get_many_by_executor(self, executor):
return self.__task_entity.get_many_by_executor(executor)
def delete_old_tasks_by_executor(self, executor, minutes):
return self.__task_entity.delete_old_tasks_by_executor(
executor, minutes)
class Metric():
__option_entity = None
__user_entity = None
__host_entity = None
__task_entity = None
__profile_entity = None
__helpers = None
__logger = None
__app_name = ""
def __init__(self):
self.__option_entity = Option_Entity()
self.__user_entity = User_Entity()
self.__host_entity = Host_Entity()
self.__task_entity = Task_Entity()
self.__profile_entity = Profile_Entity()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
self.__app_name = self.__option_entity.get_value_by_key("app_name").lower()
def get_all_users(self):
return {
"type": "count",
"record": "%s_all_users" % self.__app_name,
"count": self.__user_entity.count_all_users(),
"comment": "Current All Users on System"
}
def get_all_profiles(self):
return {
"type": "count",
"record": "%s_all_profiles" % self.__app_name,
"count": self.__profile_entity.count_all_profiles(),
"comment": "Current All Profiles on System"
}
def get_all_tasks(self):
return {
"type": "count",
"record": "%s_all_tasks" % self.__app_name,
"count": self.__task_entity.count_all_tasks(),
"comment": "Current All Tasks on System"
}
def get_all_hosts(self):
return {
"type": "count",
"record": "%s_all_hosts" % self.__app_name,
"count": self.__host_entity.count_all_hosts(),
"comment": "Current All Hosts on System"
}
class Login():
__option_entity = None
__user_entity = None
__helpers = None
__logger = None
def __init__(self):
self.__option_entity = Option_Entity()
self.__user_entity = User_Entity()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def is_authenticated(self, request):
if request.user and request.user.is_authenticated:
return True
else:
return False
def authenticate(self,
username_email,
password,
request=None,
with_login=True):
is_email = False
try:
is_email = True if validate_email(
username_email) == None else False
except Exception as e:
is_email = False
if is_email:
user = self.__user_entity.get_one_by_email(username_email)
if user != False and user.check_password(password) == True:
if with_login:
self.login(request, user)
return True
else:
return False
else:
user = authenticate(request=request,
username=username_email,
password=password)
if user is not None:
if with_login:
self.login(request, user)
return True
else:
return False
def login(self, request, user):
return login(request, user)
class Get_Image(View):
__request = None
__response = None
__helpers = None
__form = None
__logger = None
__user_id = None
__host_id = None
__image_id = None
__host_module = None
__image_module = None
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__host_module = Host_Module()
self.__image_module = Image_Module()
self.__logger = self.__helpers.get_logger(__name__)
def get(self, request, host_id, image_id):
self.__user_id = request.user.id
self.__host_id = host_id
self.__image_id = image_id
if not self.__host_module.user_owns(self.__host_id, self.__user_id):
return JsonResponse(
self.__response.send_private_failure([{
"type":
"error",
"message":
_("Error! Invalid Request.")
}]))
if self.__image_module.set_host(self.__host_id).check_health():
_image = {'long_id': self.__image_id}
return JsonResponse(
self.__response.send_private_success([], {'image': _image}))
else:
return JsonResponse(
self.__response.send_private_failure([{
"type":
"error",
"message":
_("Error! Something goes wrong with your host!")
}], {'image': {}}))
class Errors():
def __init__(self, get_response):
self.__helpers = Helpers()
self.get_response = get_response
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
response = self.get_response(request)
return response
def process_exception(self, request, exception):
if isinstance(exception, ClientError):
self.__logger.info(
_("Client error thrown %(method)s:%(path)s - %(name)s - %(exception)s"
) % {
"method": request.method,
"path": request.path,
"name": exception.__class__.__name__,
"exception": exception
})
else:
self.__logger.error(
_("The server encountered something unexpected! %(method)s:%(path)s - %(name)s - %(exception)s"
) % {
"method": request.method,
"path": request.path,
"name": exception.__class__.__name__,
"exception": exception
})
self.__logger.exception(exception)
if request.is_ajax():
return JsonResponse({
"status":
"failure",
"messages": [{
"type":
"error",
"message":
str(exception) if isinstance(exception, ClientError) else
_("Something goes wrong! Please contact a system administrator."
)
}]
})
return None
class NewRelicApps(View):
__request = None
__response = None
__helpers = None
__form = None
__logger = None
__user_id = None
__metric = None
__correlation_id = None
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__metric = MetricModule()
self.__logger = self.__helpers.get_logger(__name__)
self.__form.add_validator(ExtraRules())
@allow_if_authenticated
def get(self, request):
self.__correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
result = False
try:
result = self.__metric.get_new_relic_apps()
except Exception as e:
self.__logger.error(
_("Error while listing newrelic applications: %(error)s {'correlationId':'%(correlationId)s'}"
) % {
"error": str(e),
"correlationId": self.__correlation_id
})
if result is False:
return JsonResponse(
self.__response.send_private_failure(
[{
"type": "error",
"message": _("Error! Connecting to New Relic.")
}], {}, self.__correlation_id))
return JsonResponse(
self.__response.send_private_success([], {'apps': result},
self.__correlation_id))
class Settings():
__option_entity = None
__helpers = None
__logger = None
def __init__(self):
self.__option_entity = Option_Entity()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
def update_options(self, options):
status = True
for key, value in options.items():
status &= self.__option_entity.update_value_by_key(key, value)
return status
def wrap(controller, request, *args, **kwargs):
correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
helper = Helpers()
logger = helper.get_logger(__name__)
logger.debug(_("Request Method: %(method)s {'correlationId':'%(correlationId)s'}") % {
"method": request.method,
"correlationId": correlation_id
})
logger.debug(_("Request URL: %(path)s {'correlationId':'%(correlationId)s'}") % {
"path": request.path,
"correlationId": correlation_id
})
logger.debug(_("Request Body: %(body)s {'correlationId':'%(correlationId)s'}") % {
"body": request.body,
"correlationId": correlation_id
})
return function(controller, request, *args, **kwargs)
class APIFunnel():
def __init__(self, get_response):
self.__helpers = Helpers()
self.__funnel = Funnel()
self.get_response = get_response
self.__roles = {}
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
self.__funnel.set_rules(self.__roles)
self.__funnel.set_request(request)
if self.__funnel.action_needed():
return self.__funnel.fire()
response = self.get_response(request)
return response
class Logging():
__helpers = None
__logger = None
def __init__(self, get_response):
self.__helpers = Helpers()
self.get_response = get_response
self.__logger = self.__helpers.get_logger(__name__)
def __call__(self, request):
self.__logger.debug(_("Request Method: %s") % request.method)
self.__logger.debug(_("Request URL: %s") % request.path)
self.__logger.debug(_("Request Body: %s") % request.body)
response = self.get_response(request)
return response
class HealthCheck(View):
__response = None
__correlation_id = None
__health = None
__helpers = None
__logger = None
def get(self, request):
self.__correlation_id = request.META[
"X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__response = Response()
self.__health = Health()
self.__helpers = Helpers()
self.__logger = self.__helpers.get_logger(__name__)
status = Health.OK
errors = []
errors.extend(self.__health.check_db())
errors.extend(self.__health.check_io())
errors.extend(self.__health.check_workers())
if len(errors) > 0:
status = Health.NOT_OK
self.__logger.error(
_("Health Check Result: %(status)s %(errors)s {'correlationId':'%(correlationId)s'}"
) % {
"status": status,
"errors": self.__helpers.json_dumps(errors),
"correlationId": self.__correlation_id
})
else:
self.__logger.debug(
_("Health Check Result: %(status)s %(errors)s {'correlationId':'%(correlationId)s'}"
) % {
"status": status,
"errors": self.__helpers.json_dumps(errors),
"correlationId": self.__correlation_id
})
return JsonResponse(self.__response.send({"status": status},
self.__correlation_id),
status=200 if status == Health.OK else 503)
def handler404(request, exception=None, template_name='templates/404.html'):
helpers = Helpers()
logger = helpers.get_logger(__name__)
if exception != None:
logger.debug("Route Not Found: %s" % exception)
template_name = 'templates/404.html'
context = Context()
context.autoload_options()
context.push({
"page_title":
_("404 · %s") % context.get("app_name", os.getenv("APP_NAME", "Kevin"))
})
return render(request, template_name, context.get(), status=404)
def handler500(request, exception=None, template_name='templates/500.html'):
helpers = Helpers()
logger = helpers.get_logger(__name__)
if exception != None:
logger.error("Server Error: %s" % exception)
template_name = 'templates/500.html'
context = Context()
context.autoload_options()
context.push({
"page_title":
_("500 · %s") % context.get("app_name", os.getenv("APP_NAME", "Kevin"))
})
return render(request, template_name, context.get(), status=500)
class Health_Check(View):
__request = None
__response = None
__helpers = None
__form = None
__logger = None
__user_id = None
__host_id = None
__host_module = None
__status = None
def __init__(self):
self.__request = Request()
self.__response = Response()
self.__helpers = Helpers()
self.__form = Form()
self.__host_module = Host_Module()
self.__status = Status()
self.__logger = self.__helpers.get_logger(__name__)
def get(self, request, host_id):
self.__user_id = request.user.id
self.__host_id = host_id
if not self.__host_module.user_owns(self.__host_id, self.__user_id):
return JsonResponse(
self.__response.send_private_failure([{
"type":
"error",
"message":
_("Error! Invalid Request.")
}]))
health = self.__status.set_host(self.__host_id).ping()
if health:
return JsonResponse(
self.__response.send_private_success([], {"status": "up"}))
else:
return JsonResponse(
self.__response.send_private_success([], {"status": "down"}))
