Scott Baker | 8df8166 | 2016-08-05 09:29:35 -0700 | [diff] [blame] | 1 | from rest_framework.decorators import api_view |
| 2 | from rest_framework.response import Response |
| 3 | from rest_framework.reverse import reverse |
| 4 | from rest_framework import serializers |
| 5 | from rest_framework import generics |
| 6 | from rest_framework.views import APIView |
| 7 | from core.models import * |
| 8 | from services.hpc.models import * |
| 9 | from services.requestrouter.models import * |
| 10 | from django.forms import widgets |
| 11 | from django.core.exceptions import PermissionDenied |
| 12 | from django.contrib.contenttypes.models import ContentType |
| 13 | import json |
| 14 | import socket |
| 15 | import time |
| 16 | |
| 17 | # This REST API endpoint contains a bunch of misc information that the |
| 18 | # tenant view needs to display |
| 19 | |
| 20 | def get_service_slices(service): |
| 21 | try: |
| 22 | return service.slices.all() |
| 23 | except: |
| 24 | return service.service.all() |
| 25 | |
| 26 | def lookup_tag(service, instance, name, default=None): |
| 27 | instance_type = ContentType.objects.get_for_model(instance) |
| 28 | t = Tag.objects.filter(service=service, name=name, content_type__pk=instance_type.id, object_id=instance.id) |
| 29 | if t: |
| 30 | return t[0].value |
| 31 | else: |
| 32 | return default |
| 33 | |
| 34 | def lookup_time(service, instance, name): |
| 35 | v = lookup_tag(service, instance, name) |
| 36 | if v: |
| 37 | return str(time.time() - float(v)) |
| 38 | else: |
| 39 | return None |
| 40 | |
| 41 | def json_default(d, default): |
| 42 | if not d: |
| 43 | return default |
| 44 | return json.loads(d) |
| 45 | |
| 46 | def compute_config_run(d): |
| 47 | if not d: |
| 48 | return "null" |
| 49 | |
| 50 | try: |
| 51 | d = json.loads(d) |
| 52 | except: |
| 53 | return "error decoding json '%s'" % str(d) |
| 54 | |
| 55 | status = d.get("status", "null") |
| 56 | if status!="success": |
| 57 | return status |
| 58 | |
| 59 | config_run = d.get("config.run") |
| 60 | if not config_run: |
| 61 | return "null" |
| 62 | |
| 63 | try: |
| 64 | config_run = max(0, int(time.time()) - int(float(config_run))) |
| 65 | except: |
| 66 | pass |
| 67 | |
| 68 | return config_run |
| 69 | |
| 70 | # from hpc_watcher.py |
| 71 | def get_public_ip(service, instance): |
| 72 | network_name = None |
| 73 | if "hpc" in instance.slice.name: |
| 74 | network_name = getattr(service, "watcher_hpc_network", None) |
| 75 | elif "demux" in instance.slice.name: |
| 76 | network_name = getattr(service, "watcher_dnsdemux_network", None) |
| 77 | elif "redir" in instance.slice.name: |
| 78 | network_name = getattr(service, "watcher_dnsredir_network", None) |
| 79 | |
| 80 | if network_name and network_name.lower()=="nat": |
| 81 | return None |
| 82 | |
| 83 | if (network_name is None) or (network_name=="") or (network_name.lower()=="public"): |
| 84 | return instance.get_public_ip() |
| 85 | |
| 86 | for ns in instance.ports.all(): |
| 87 | if (ns.ip) and (ns.network.name==network_name): |
| 88 | return ns.ip |
| 89 | |
| 90 | raise ValueError("Couldn't find network %s" % str(network_name)) |
| 91 | |
| 92 | def getHpcDict(user, pk): |
| 93 | hpc = HpcService.objects.get(pk=pk) |
| 94 | slices = get_service_slices(hpc) |
| 95 | |
| 96 | dnsdemux_slice = None |
| 97 | dnsredir_slice = None |
| 98 | hpc_slice = None |
| 99 | for slice in slices: |
| 100 | if "dnsdemux" in slice.name: |
| 101 | dnsdemux_service = hpc |
| 102 | dnsdemux_slice = slice |
| 103 | if "dnsredir" in slice.name: |
| 104 | dnsredir_service = hpc |
| 105 | dnsredir_slice = slice |
| 106 | if "hpc" in slice.name: |
| 107 | hpc_service = hpc |
| 108 | hpc_slice = slice |
| 109 | |
| 110 | if not dnsdemux_slice: |
| 111 | rr = RequestRouterService.objects.all() |
| 112 | if rr: |
| 113 | rr=rr[0] |
| 114 | slices = get_service_slices(rr) |
| 115 | for slice in slices: |
| 116 | if "dnsdemux" in slice.name: |
| 117 | dnsdemux_service = rr |
| 118 | dnsdemux_slice = slice |
| 119 | if "dnsredir" in slice.name: |
| 120 | dnsredir_service = rr |
| 121 | dnsredir_slice = slice |
| 122 | |
| 123 | if not dnsredir_slice: |
| 124 | print "no dnsredir slice" |
| 125 | return |
| 126 | |
| 127 | if not dnsdemux_slice: |
| 128 | print "no dnsdemux slice" |
| 129 | return |
| 130 | |
| 131 | #dnsdemux_has_public_network = False |
| 132 | #for network in dnsdemux_slice.networks.all(): |
| 133 | # if (network.template) and (network.template.visibility=="public") and (network.template.translation=="none"): |
| 134 | # dnsdemux_has_public_network = True |
| 135 | |
| 136 | nameservers = {} |
| 137 | for nshc in hpc.hpchealthcheck_set.filter(kind="nameserver"): |
| 138 | nameserver = nshc.resource_name |
| 139 | try: |
| 140 | nameservers[nameserver] = {"name": nameserver, "ip": socket.gethostbyname(nameserver), "hit": False} |
| 141 | except: |
| 142 | nameservers[nameserver] = {"name": nameserver, "ip": "exception", "hit": False} |
| 143 | |
| 144 | dnsdemux=[] |
| 145 | for instance in dnsdemux_slice.instances.all(): |
| 146 | ip=None |
| 147 | try: |
| 148 | ip = get_public_ip(dnsdemux_service, instance) |
| 149 | except Exception, e: |
| 150 | ip = "Exception: " + str(e) |
| 151 | if not ip: |
| 152 | try: |
| 153 | ip = socket.gethostbyname(instance.node.name) |
| 154 | except: |
| 155 | ip = "??? " + instance.node.name |
| 156 | |
| 157 | instance_nameservers = [] |
| 158 | for ns in nameservers.values(): |
| 159 | if ns["ip"]==ip: |
| 160 | instance_nameservers.append(ns["name"]) |
| 161 | ns["hit"]=True |
| 162 | |
| 163 | # now find the dnsredir instance that is also on this node |
| 164 | watcherd_dnsredir = "no-redir-instance" |
| 165 | for dnsredir_instance in dnsredir_slice.instances.all(): |
| 166 | if dnsredir_instance.node == instance.node: |
| 167 | watcherd_dnsredir = lookup_tag(dnsredir_service, dnsredir_instance, "watcher.watcher.msg") |
| 168 | |
| 169 | watcherd_dnsdemux = lookup_tag(dnsdemux_service, instance, "watcher.watcher.msg") |
| 170 | |
| 171 | dnsdemux.append( {"name": instance.node.name, |
| 172 | "watcher.DNS.msg": lookup_tag(dnsdemux_service, instance, "watcher.DNS.msg"), |
| 173 | "watcher.DNS.time": lookup_time(dnsdemux_service, instance, "watcher.DNS.time"), |
| 174 | "ip": ip, |
| 175 | "nameservers": instance_nameservers, |
| 176 | "dnsdemux_config_age": compute_config_run(watcherd_dnsdemux), |
| 177 | "dnsredir_config_age": compute_config_run(watcherd_dnsredir) }) |
| 178 | |
| 179 | hpc=[] |
| 180 | for instance in hpc_slice.instances.all(): |
| 181 | watcherd_hpc = lookup_tag(hpc_service, instance, "watcher.watcher.msg") |
| 182 | |
| 183 | hpc.append( {"name": instance.node.name, |
| 184 | "watcher.HPC-hb.msg": lookup_tag(hpc_service, instance, "watcher.HPC-hb.msg"), |
| 185 | "watcher.HPC-hb.time": lookup_time(hpc_service, instance, "watcher.HPC-hb.time"), |
| 186 | "watcher.HPC-fetch.msg": lookup_tag(hpc_service, instance, "watcher.HPC-fetch.msg"), |
| 187 | "watcher.HPC-fetch.time": lookup_time(hpc_service, instance, "watcher.HPC-fetch.time"), |
| 188 | "watcher.HPC-fetch.urls": json_default(lookup_tag(hpc_service, instance, "watcher.HPC-fetch-urls.msg"), []), |
| 189 | "config_age": compute_config_run(watcherd_hpc), |
| 190 | |
| 191 | }) |
| 192 | |
| 193 | return { "id": pk, |
| 194 | "dnsdemux": dnsdemux, |
| 195 | "hpc": hpc, |
| 196 | "nameservers": nameservers,} |
| 197 | |
| 198 | |
| 199 | class HpcList(APIView): |
| 200 | method_kind = "list" |
| 201 | method_name = "hpcview" |
| 202 | |
| 203 | def get(self, request, format=None): |
| 204 | if (not request.user.is_authenticated()): |
| 205 | raise PermissionDenied("You must be authenticated in order to use this API") |
| 206 | results = [] |
| 207 | for hpc in HpcService.objects.all(): |
| 208 | results.append(getHpcDict(request.user, hpc.pk)) |
| 209 | return Response( results ) |
| 210 | |
| 211 | class HpcDetail(APIView): |
| 212 | method_kind = "detail" |
| 213 | method_name = "hpcview" |
| 214 | |
| 215 | def get(self, request, format=None, pk=0): |
| 216 | if (not request.user.is_authenticated()): |
| 217 | raise PermissionDenied("You must be authenticated in order to use this API") |
| 218 | return Response( [getHpcDict(request.user, pk)] ) |
| 219 | |