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"}))