from datetime import timedelta as td import time from django.conf import settings from django.db import connection from django.http import ( HttpResponse, HttpResponseForbidden, HttpResponseNotFound, HttpResponseBadRequest, JsonResponse, ) from django.shortcuts import get_object_or_404 from django.utils import timezone from django.views.decorators.cache import never_cache from django.views.decorators.csrf import csrf_exempt from django.views.decorators.http import require_POST from hc.accounts.models import Profile from hc.api import schemas from hc.api.decorators import authorize, authorize_read, cors, validate_json from hc.api.forms import FlipsFiltersForm from hc.api.models import MAX_DELTA, Flip, Channel, Check, Notification, Ping from hc.lib.badges import check_signature, get_badge_svg class BadChannelException(Exception): pass @csrf_exempt @never_cache def ping(request, code, action="success", exitstatus=None): check = get_object_or_404(Check, code=code) headers = request.META remote_addr = headers.get("HTTP_X_FORWARDED_FOR", headers["REMOTE_ADDR"]) remote_addr = remote_addr.split(",")[0] scheme = headers.get("HTTP_X_FORWARDED_PROTO", "http") method = headers["REQUEST_METHOD"] ua = headers.get("HTTP_USER_AGENT", "") body = request.body.decode() if exitstatus is not None and exitstatus > 0: action = "fail" if check.methods == "POST" and method != "POST": action = "ign" check.ping(remote_addr, scheme, method, ua, body, action, exitstatus) response = HttpResponse("OK") response["Access-Control-Allow-Origin"] = "*" return response def _lookup(project, spec): unique_fields = spec.get("unique", []) if unique_fields: existing_checks = Check.objects.filter(project=project) if "name" in unique_fields: existing_checks = existing_checks.filter(name=spec.get("name")) if "tags" in unique_fields: existing_checks = existing_checks.filter(tags=spec.get("tags")) if "timeout" in unique_fields: timeout = td(seconds=spec["timeout"]) existing_checks = existing_checks.filter(timeout=timeout) if "grace" in unique_fields: grace = td(seconds=spec["grace"]) existing_checks = existing_checks.filter(grace=grace) return existing_checks.first() def _update(check, spec): # First, validate the supplied channel codes/names if "channels" not in spec: # If the channels key is not present, don't update check's channels new_channels = None elif spec["channels"] == "*": # "*" means "all project's channels" new_channels = Channel.objects.filter(project=check.project) elif spec.get("channels") == "": # "" means "empty list" new_channels = [] else: # expect a comma-separated list of channel codes or names new_channels = set() available = list(Channel.objects.filter(project=check.project)) for s in spec["channels"].split(","): if s == "": raise BadChannelException("empty channel identifier") matches = [c for c in available if str(c.code) == s or c.name == s] if len(matches) == 0: raise BadChannelException("invalid channel identifier: %s" % s) elif len(matches) > 1: raise BadChannelException("non-unique channel identifier: %s" % s) new_channels.add(matches[0]) need_save = False if check.pk is None: # Empty pk means we're inserting a new check, # and so do need to save() it: need_save = True if "name" in spec and check.name != spec["name"]: check.name = spec["name"] need_save = True if "tags" in spec and check.tags != spec["tags"]: check.tags = spec["tags"] need_save = True if "desc" in spec and check.desc != spec["desc"]: check.desc = spec["desc"] need_save = True if "manual_resume" in spec and check.manual_resume != spec["manual_resume"]: check.manual_resume = spec["manual_resume"] need_save = True if "methods" in spec and check.methods != spec["methods"]: check.methods = spec["methods"] need_save = True if "timeout" in spec and "schedule" not in spec: new_timeout = td(seconds=spec["timeout"]) if check.kind != "simple" or check.timeout != new_timeout: check.kind = "simple" check.timeout = new_timeout need_save = True if "grace" in spec: new_grace = td(seconds=spec["grace"]) if check.grace != new_grace: check.grace = new_grace need_save = True if "schedule" in spec: if check.kind != "cron" or check.schedule != spec["schedule"]: check.kind = "cron" check.schedule = spec["schedule"] need_save = True if "tz" in spec and check.tz != spec["tz"]: check.tz = spec["tz"] need_save = True if need_save: check.alert_after = check.going_down_after() check.save() # This needs to be done after saving the check, because of # the M2M relation between checks and channels: if new_channels is not None: check.channel_set.set(new_channels) return check @validate_json() @authorize_read def get_checks(request): q = Check.objects.filter(project=request.project) if not request.readonly: q = q.prefetch_related("channel_set") tags = set(request.GET.getlist("tag")) for tag in tags: # approximate filtering by tags q = q.filter(tags__contains=tag) checks = [] for check in q: # precise, final filtering if not tags or check.matches_tag_set(tags): checks.append(check.to_dict(readonly=request.readonly)) return JsonResponse({"checks": checks}) @validate_json(schemas.check) @authorize def create_check(request): created = False check = _lookup(request.project, request.json) if check is None: if request.project.num_checks_available() <= 0: return HttpResponseForbidden() check = Check(project=request.project) created = True try: _update(check, request.json) except BadChannelException as e: return JsonResponse({"error": str(e)}, status=400) return JsonResponse(check.to_dict(), status=201 if created else 200) @csrf_exempt @cors("GET", "POST") def checks(request): if request.method == "POST": return create_check(request) return get_checks(request) @cors("GET") @validate_json() @authorize def channels(request): q = Channel.objects.filter(project=request.project) channels = [ch.to_dict() for ch in q] return JsonResponse({"channels": channels}) @validate_json() @authorize_read def get_check(request, code): check = get_object_or_404(Check, code=code) if check.project_id != request.project.id: return HttpResponseForbidden() return JsonResponse(check.to_dict(readonly=request.readonly)) @cors("GET") @csrf_exempt @validate_json() @authorize_read def get_check_by_unique_key(request, unique_key): checks = Check.objects.filter(project=request.project.id) for check in checks: if check.unique_key == unique_key: return JsonResponse(check.to_dict(readonly=request.readonly)) return HttpResponseNotFound() @validate_json(schemas.check) @authorize def update_check(request, code): check = get_object_or_404(Check, code=code) if check.project_id != request.project.id: return HttpResponseForbidden() try: _update(check, request.json) except BadChannelException as e: return JsonResponse({"error": str(e)}, status=400) return JsonResponse(check.to_dict()) @validate_json() @authorize def delete_check(request, code): check = get_object_or_404(Check, code=code) if check.project_id != request.project.id: return HttpResponseForbidden() response = check.to_dict() check.delete() return JsonResponse(response) @csrf_exempt @cors("POST", "DELETE", "GET") def single(request, code): if request.method == "POST": return update_check(request, code) if request.method == "DELETE": return delete_check(request, code) return get_check(request, code) @cors("POST") @csrf_exempt @validate_json() @authorize def pause(request, code): check = get_object_or_404(Check, code=code) if check.project_id != request.project.id: return HttpResponseForbidden() check.status = "paused" check.last_start = None check.alert_after = None check.save() return JsonResponse(check.to_dict()) @cors("GET") @validate_json() @authorize def pings(request, code): check = get_object_or_404(Check, code=code) if check.project_id != request.project.id: return HttpResponseForbidden() # Look up ping log limit from account's profile. # There might be more pings in the database (depends on how pruning is handled) # but we will not return more than the limit allows. profile = Profile.objects.get(user__project=request.project) limit = profile.ping_log_limit # Query in descending order so we're sure to get the most recent # pings, regardless of the limit restriction pings = Ping.objects.filter(owner=check).order_by("-id")[:limit] # Ascending order is more convenient for calculating duration, so use reverse() prev, dicts = None, [] for ping in reversed(pings): d = ping.to_dict() if ping.kind != "start" and prev and prev.kind == "start": delta = ping.created - prev.created if delta < MAX_DELTA: d["duration"] = delta.total_seconds() dicts.insert(0, d) prev = ping return JsonResponse({"pings": dicts}) def flips(request, check): if check.project_id != request.project.id: return HttpResponseForbidden() form = FlipsFiltersForm(request.GET) if not form.is_valid(): return HttpResponseBadRequest() flips = Flip.objects.filter(owner=check).order_by("-id") if form.cleaned_data["start"]: flips = flips.filter(created__gte=form.cleaned_data["start"]) if form.cleaned_data["end"]: flips = flips.filter(created__lt=form.cleaned_data["end"]) if form.cleaned_data["seconds"]: threshold = timezone.now() - td(seconds=form.cleaned_data["seconds"]) flips = flips.filter(created__gte=threshold) return JsonResponse({"flips": [flip.to_dict() for flip in flips]}) @cors("GET") @csrf_exempt @validate_json() @authorize_read def flips_by_uuid(request, code): check = get_object_or_404(Check, code=code) return flips(request, check) @cors("GET") @csrf_exempt @validate_json() @authorize_read def flips_by_unique_key(request, unique_key): checks = Check.objects.filter(project=request.project.id) for check in checks: if check.unique_key == unique_key: return flips(request, check) return HttpResponseNotFound() @never_cache @cors("GET") def badge(request, badge_key, signature, tag, fmt): if fmt not in ("svg", "json", "shields"): return HttpResponseNotFound() with_late = True if len(signature) == 10 and signature.endswith("-2"): with_late = False if not check_signature(badge_key, tag, signature): return HttpResponseNotFound() q = Check.objects.filter(project__badge_key=badge_key) if tag != "*": q = q.filter(tags__contains=tag) label = tag else: label = settings.MASTER_BADGE_LABEL status, total, grace, down = "up", 0, 0, 0 for check in q: if tag != "*" and tag not in check.tags_list(): continue total += 1 check_status = check.get_status() if check_status == "down": down += 1 status = "down" if fmt == "svg": # For SVG badges, we can leave the loop as soon as we # find the first "down" break elif check_status == "grace": grace += 1 if status == "up" and with_late: status = "late" if fmt == "shields": color = "success" if status == "down": color = "critical" elif status == "late": color = "important" return JsonResponse({"label": label, "message": status, "color": color}) if fmt == "json": return JsonResponse( {"status": status, "total": total, "grace": grace, "down": down} ) svg = get_badge_svg(label, status) return HttpResponse(svg, content_type="image/svg+xml") @csrf_exempt @require_POST def notification_status(request, code): """ Handle notification delivery status callbacks. """ try: cutoff = timezone.now() - td(hours=1) notification = Notification.objects.get(code=code, created__gt=cutoff) except Notification.DoesNotExist: # If the notification does not exist, or is more than a hour old, # return HTTP 200 so the other party doesn't retry over and over again: return HttpResponse() error, mark_not_verified = None, False # Look for "error" and "mark_not_verified" keys: if request.POST.get("error"): error = request.POST["error"][:200] mark_not_verified = request.POST.get("mark_not_verified") # Handle "MessageStatus" key from Twilio if request.POST.get("MessageStatus") in ("failed", "undelivered"): status = request.POST["MessageStatus"] error = f"Delivery failed (status={status})." # Handle "CallStatus" key from Twilio if request.POST.get("CallStatus") == "failed": error = f"Delivery failed (status=failed)." if error: notification.error = error notification.save(update_fields=["error"]) channel_q = Channel.objects.filter(id=notification.channel_id) channel_q.update(last_error=error) if mark_not_verified: channel_q.update(email_verified=False) return HttpResponse() def metrics(request): if not settings.METRICS_KEY: return HttpResponseForbidden() key = request.META.get("HTTP_X_METRICS_KEY") if key != settings.METRICS_KEY: return HttpResponseForbidden() doc = { "ts": int(time.time()), "max_ping_id": Ping.objects.values_list("id", flat=True).last(), "max_notification_id": Notification.objects.values_list("id", flat=True).last(), "num_unprocessed_flips": Flip.objects.filter(processed__isnull=True).count(), } return JsonResponse(doc) def status(request): with connection.cursor() as c: c.execute("SELECT 1") c.fetchone() return HttpResponse("OK")