Siobhan Tully | cf04fb6 | 2014-01-11 11:25:57 -0500 | [diff] [blame] | 1 | #views.py |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 2 | import functools |
| 3 | import math |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 4 | import os |
| 5 | import sys |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 6 | from django.views.generic import TemplateView, View |
| 7 | import datetime |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 8 | from pprint import pprint |
| 9 | import json |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 10 | from syndicate.models import * |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 11 | from core.models import * |
Scott Baker | e9f4ec9 | 2014-04-29 11:29:45 -0700 | [diff] [blame] | 12 | from hpc.models import ContentProvider |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 13 | from operator import attrgetter |
Scott Baker | 186ae61 | 2014-05-19 10:42:51 -0700 | [diff] [blame^] | 14 | from django import template |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 15 | from django.views.decorators.csrf import csrf_exempt |
| 16 | from django.http import HttpResponse, HttpResponseServerError |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 17 | from django.core import urlresolvers |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 18 | from django.contrib.gis.geoip import GeoIP |
| 19 | from ipware.ip import get_ip |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 20 | import traceback |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 21 | import socket |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 22 | |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 23 | BLESSED_SITES = ["Stanford", "Washington", "Princeton", "GeorgiaTech", "MaxPlanck"] |
| 24 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 25 | if os.path.exists("/home/smbaker/projects/vicci/cdn/bigquery"): |
| 26 | sys.path.append("/home/smbaker/projects/vicci/cdn/bigquery") |
| 27 | else: |
| 28 | sys.path.append("/opt/planetstack/hpc_wizard") |
| 29 | import hpc_wizard |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 30 | from planetstack_analytics import DoPlanetStackAnalytics, PlanetStackAnalytics, RED_LOAD, BLUE_LOAD |
Siobhan Tully | cf04fb6 | 2014-01-11 11:25:57 -0500 | [diff] [blame] | 31 | |
| 32 | class DashboardWelcomeView(TemplateView): |
| 33 | template_name = 'admin/dashboard/welcome.html' |
| 34 | |
| 35 | def get(self, request, *args, **kwargs): |
| 36 | context = self.get_context_data(**kwargs) |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 37 | userDetails = getUserSliceInfo(request.user) |
| 38 | #context['site'] = userDetails['site'] |
Siobhan Tully | cf04fb6 | 2014-01-11 11:25:57 -0500 | [diff] [blame] | 39 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 40 | context['userSliceInfo'] = userDetails['userSliceInfo'] |
| 41 | context['cdnData'] = userDetails['cdnData'] |
Scott Baker | e9f4ec9 | 2014-04-29 11:29:45 -0700 | [diff] [blame] | 42 | context['cdnContentProviders'] = userDetails['cdnContentProviders'] |
Siobhan Tully | cf04fb6 | 2014-01-11 11:25:57 -0500 | [diff] [blame] | 43 | return self.render_to_response(context=context) |
Siobhan Tully | e18b344 | 2014-02-23 14:23:34 -0500 | [diff] [blame] | 44 | |
Scott Baker | 186ae61 | 2014-05-19 10:42:51 -0700 | [diff] [blame^] | 45 | class DashboardView(TemplateView): |
| 46 | head_template = r"""{% extends "admin/dashboard/dashboard_base.html" %} |
| 47 | {% load admin_static %} |
| 48 | {% block content %} |
| 49 | """ |
| 50 | |
| 51 | tail_template = r"{% endblock %}" |
| 52 | |
| 53 | def get(self, request, name="hpc_historical", *args, **kwargs): |
| 54 | context = self.get_context_data(**kwargs) |
| 55 | |
| 56 | t = template.Template(self.head_template + open("/opt/planetstack/templates/admin/dashboard/%s.html" % name, "r").read() + self.tail_template) |
| 57 | |
| 58 | userDetails = getUserSliceInfo(request.user) |
| 59 | #context['site'] = userDetails['site'] |
| 60 | |
| 61 | context['userSliceInfo'] = userDetails['userSliceInfo'] |
| 62 | context['cdnData'] = userDetails['cdnData'] |
| 63 | context['cdnContentProviders'] = userDetails['cdnContentProviders'] |
| 64 | |
| 65 | response_kwargs = {} |
| 66 | response_kwargs.setdefault('content_type', self.content_type) |
| 67 | return self.response_class(
|
| 68 | request = request,
|
| 69 | template = t,
|
| 70 | context = context,
|
| 71 | **response_kwargs) |
| 72 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 73 | def getUserSliceInfo(user, tableFormat = False): |
| 74 | userDetails = {} |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 75 | |
| 76 | userSliceData = getSliceInfo(user) |
| 77 | if (tableFormat): |
| 78 | # pprint("******* GET USER SLICE INFO") |
| 79 | userDetails['userSliceInfo'] = userSliceTableFormatter(userSliceData) |
| 80 | else: |
| 81 | userDetails['userSliceInfo'] = userSliceData |
Scott Baker | e9f4ec9 | 2014-04-29 11:29:45 -0700 | [diff] [blame] | 82 | userDetails['cdnData'] = getCDNOperatorData(wait=False) |
| 83 | userDetails['cdnContentProviders'] = getCDNContentProviderData() |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 84 | return userDetails |
| 85 | |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 86 | class TenantCreateSlice(View): |
| 87 | def post(self, request, *args, **kwargs): |
| 88 | sliceName = request.POST.get("sliceName", "0") |
| 89 | serviceClass = request.POST.get("serviceClass", "0") |
| 90 | imageName = request.POST.get("imageName", "0") |
| 91 | actionToDo = request.POST.get("actionToDo", "0") |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 92 | #network = request.POST.get("network","0") |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 93 | mountDataSets = request.POST.get("mountDataSets","0") |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 94 | if (actionToDo == "add"): |
| 95 | serviceClass = ServiceClass.objects.get(name=serviceClass) |
| 96 | site = request.user.site |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 97 | image = Image.objects.get(name=imageName) |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 98 | newSlice = Slice(name=sliceName,serviceClass=serviceClass,site=site,imagePreference=image,mountDataSets=mountDataSets) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 99 | newSlice.save() |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 100 | return HttpResponse("Slice created") |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 101 | |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 102 | class TenantUpdateSlice(View): |
| 103 | def post(self, request, *args, **kwargs):
|
| 104 | sliceName = request.POST.get("sliceName", "0")
|
| 105 | serviceClass = request.POST.get("serviceClass", "0")
|
| 106 | imageName = request.POST.get("imageName", "0")
|
| 107 | actionToDo = request.POST.get("actionToDo", "0")
|
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 108 | #network = request.POST.get("network","0")
|
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 109 | dataSet = request.POST.get("dataSet","0")
|
| 110 | slice = Slice.objects.all()
|
| 111 | for entry in slice:
|
| 112 | serviceClass = ServiceClass.objects.get(name=serviceClass)
|
| 113 | if(entry.name==sliceName):
|
| 114 | if (actionToDo == "update"):
|
| 115 | setattr(entry,'serviceClass',serviceClass)
|
| 116 | setattr(entry,'imagePreference',imageName)
|
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 117 | #setattr(entry,'network',network)
|
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 118 | setattr(entry,'mountDataSets',dataSet)
|
| 119 | entry.save()
|
| 120 | break
|
| 121 | return HttpResponse("Slice updated")
|
| 122 |
|
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 123 | def getTenantSliceInfo(user, tableFormat = False): |
| 124 | tenantSliceDetails = {} |
| 125 | tenantSliceData = getTenantInfo(user) |
| 126 | tenantServiceClassData = getServiceClassInfo(user) |
| 127 | if (tableFormat): |
| 128 | tenantSliceDetails['userSliceInfo'] = userSliceTableFormatter(tenantSliceData) |
| 129 | tenantSliceDetails['sliceServiceClass']=userSliceTableFormatter(tenantServiceClassData) |
| 130 | else: |
| 131 | tenantSliceDetails['userSliceInfo'] = tenantSliceData |
| 132 | tenantSliceDetails['sliceServiceClass']=userSliceTableFormatter(tenantServiceClassData) |
| 133 | tenantSliceDetails['image']=userSliceTableFormatter(getImageInfo(user)) |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 134 | #tenantSliceDetails['network']=userSliceTableFormatter(getNetworkInfo(user)) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 135 | tenantSliceDetails['deploymentSites']=userSliceTableFormatter(getDeploymentSites()) |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 136 | tenantSliceDetails['sites'] = userSliceTableFormatter(getTenantSitesInfo()) |
| 137 | tenantSliceDetails['mountDataSets'] = userSliceTableFormatter(getMountDataSets()) |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 138 | tenantSliceDetails['publicKey'] = getPublicKey(user) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 139 | return tenantSliceDetails |
| 140 | |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 141 | def getTenantInfo(user): |
| 142 | slices =Slice.objects.all() |
| 143 | userSliceInfo = [] |
| 144 | for entry in slices: |
| 145 | sliceName = Slice.objects.get(id=entry.id).name |
| 146 | slice = Slice.objects.get(name=Slice.objects.get(id=entry.id).name) |
| 147 | sliceServiceClass = entry.serviceClass.name |
| 148 | preferredImage = entry.imagePreference |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 149 | sliceDataSet = entry.mountDataSets |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 150 | #sliceNetwork = entry.network |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 151 | numSliver = 0 |
| 152 | sliceImage="" |
| 153 | sliceSite = {} |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 154 | sliceNode = {} |
| 155 | sliceInstance= {} |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 156 | for sliver in slice.slivers.all(): |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 157 | if sliver.node.site.name in BLESSED_SITES: |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 158 | sliceSite[sliver.node.site.name] = sliceSite.get(sliver.node.site.name,0) + 1 |
| 159 | sliceImage = sliver.image.name |
Scott Baker | b37ce33 | 2014-04-22 22:57:40 -0700 | [diff] [blame] | 160 | sliceNode[str(sliver)] = sliver.node.name |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 161 | numSliver = sum(sliceSite.values()) |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 162 | numSites = len(sliceSite) |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 163 | userSliceInfo.append({'sliceName': sliceName,'sliceServiceClass': sliceServiceClass,'preferredImage':preferredImage,'numOfSites':numSites, 'sliceSite':sliceSite,'sliceImage':sliceImage,'numOfSlivers':numSliver,'sliceDataSet':sliceDataSet,'instanceNodePair':sliceNode}) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 164 | return userSliceInfo |
| 165 | |
| 166 | def getTenantSitesInfo(): |
| 167 | tenantSiteInfo=[] |
| 168 | for entry in Site.objects.all(): |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 169 | if entry.name in BLESSED_SITES: |
| 170 | tenantSiteInfo.append({'siteName':entry.name}) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 171 | return tenantSiteInfo |
| 172 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 173 | def userSliceTableFormatter(data): |
| 174 | # pprint(data) |
| 175 | formattedData = { |
| 176 | 'rows' : data |
| 177 | } |
| 178 | return formattedData |
| 179 | |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 180 | def getPublicKey(user): |
| 181 | users=User.objects.all()
|
| 182 | for key in users:
|
| 183 | if (str(key.email)==str(user)):
|
| 184 | sshKey = key.public_key
|
| 185 | return sshKey |
| 186 | |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 187 | def getServiceClassInfo(user): |
| 188 | serviceClassList = ServiceClass.objects.all() |
| 189 | sliceInfo = [] |
| 190 | for entry in serviceClassList: |
| 191 | sliceInfo.append({'serviceClass':entry.name}) |
| 192 | return sliceInfo |
| 193 | |
| 194 | def getImageInfo(user): |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 195 | imageList = Image.objects.all() |
| 196 | #imageList = ['Fedora 16 LXC rev 1.3','Hadoop','MPI'] |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 197 | imageInfo = [] |
| 198 | for imageEntry in imageList: |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 199 | imageInfo.append({'Image':imageEntry.name}) |
| 200 | #imageInfo.append({'Image':imageEntry}) |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 201 | return imageInfo |
| 202 | |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 203 | def createPrivateVolume(user, sliceName): |
| 204 | caps = Volume.CAP_READ_DATA | Volume.CAP_WRITE_DATA | Volume.CAP_HOST_DATA |
| 205 | getattr(Volume.default_gateway_caps,"read data") | \ |
| 206 | getattr(Volume.default_gateway_caps,"write data") | \ |
| 207 | getattr(Volume.default_gateway_caps,"host files") |
| 208 | v = Volume(name="private_" + sliceName, owner_id=user, description="private volume for %s" % sliceName, blocksize=61440, private=True, archive=False, default_gateway_caps = caps) |
| 209 | v.save() |
| 210 | |
| 211 | SYNDICATE_REPLICATE_PORTNUM = 1025 |
| 212 | |
| 213 | def get_free_port(): |
| 214 | inuse={} |
| 215 | inuse[SYNDICATE_REPLICATE_PORTNUM] = True |
| 216 | for vs in VolumeSlice.objects.all(): |
| 217 | inuse[vs.peer_portnum]=True |
| 218 | inuse[vs.replicate_portnum]=True |
| 219 | for network in Network.objects.all(): |
| 220 | network_ports = [x.strip() for x in network.ports.split(",")] |
| 221 | for network_port in network_ports: |
| 222 | try: |
| 223 | inuse[int(network_port)] = True |
| 224 | except: |
| 225 | # in case someone has put a malformed port number in the list |
| 226 | pass |
| 227 | for i in range(1025, 65535): |
| 228 | if not inuse.get(i,False): |
| 229 | return i |
| 230 | return False |
| 231 | |
| 232 | def mountVolume(sliceName, volumeName, readWrite): |
| 233 | slice = Slice.objects.get(name=sliceName) |
| 234 | volume = Volume.objects.get(name=volumeName) |
| 235 | # choose some unused port numbers |
| 236 | flags = Volume.CAP_READ_DATA |
| 237 | if readWrite: |
| 238 | flags = flags | Volume.CAP_WRITE_DATA |
| 239 | vs = VolumeSlice(volume_id = volume, slice_id = slice, gateway_caps=flags, peer_portnum = get_free_port(), replicate_portnum = SYNDICATE_REPLICATE_PORTNUM) |
| 240 | vs.save() |
| 241 | |
| 242 | def hasPrivateVolume(sliceName): |
| 243 | slice = Slice.objects.get(name=sliceName) |
| 244 | for vs in VolumeSlice.objects.filter(slice_id=slice): |
| 245 | if vs.volume_id.private: |
| 246 | return True |
| 247 | return False |
| 248 | |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 249 | def getMountDataSets(): |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 250 | dataSetInfo=[]
|
| 251 | for volume in Volume.objects.all():
|
| 252 | if not volume.private:
|
| 253 | dataSetInfo.append({'DataSet': volume.name})
|
| 254 |
|
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 255 | return dataSetInfo |
| 256 | |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 257 | def getNetworkInfo(user): |
| 258 | #networkList = Network.objects.all() |
| 259 | networkList = ['Private Only','Private and Publicly Routable'] |
| 260 | networkInfo = [] |
| 261 | for networkEntry in networkList: |
| 262 | #networkInfo.append({'Network':networkEntry.name}) |
| 263 | networkInfo.append({'Network':networkEntry}) |
| 264 | return networkInfo |
| 265 | |
| 266 | def getDeploymentSites(): |
| 267 | deploymentList = Deployment.objects.all() |
| 268 | deploymentInfo = [] |
| 269 | for entry in deploymentList: |
| 270 | deploymentInfo.append({'DeploymentSite':entry.name}) |
| 271 | return deploymentInfo |
| 272 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 273 | def getSliceInfo(user): |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 274 | sliceList = Slice.objects.all() |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 275 | slicePrivs = SlicePrivilege.objects.filter(user=user) |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 276 | userSliceInfo = [] |
| 277 | for entry in slicePrivs: |
Siobhan Tully | e18b344 | 2014-02-23 14:23:34 -0500 | [diff] [blame] | 278 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 279 | slicename = Slice.objects.get(id=entry.slice.id).name |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 280 | slice = Slice.objects.get(name=Slice.objects.get(id=entry.slice.id).name) |
| 281 | sliverList=Sliver.objects.all() |
| 282 | sites_used = {} |
| 283 | for sliver in slice.slivers.all(): |
| 284 | #sites_used['deploymentSites'] = sliver.node.deployment.name |
| 285 | # sites_used[sliver.image.name] = sliver.image.name |
| 286 | sites_used[sliver.node.site.name] = sliver.numberCores |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 287 | sliceid = Slice.objects.get(id=entry.slice.id).id |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 288 | try: |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 289 | sliverList = Sliver.objects.filter(slice=entry.slice.id) |
| 290 | siteList = {} |
| 291 | for x in sliverList: |
| 292 | if x.node.site not in siteList: |
| 293 | siteList[x.node.site] = 1 |
| 294 | slivercount = len(sliverList) |
| 295 | sitecount = len(siteList) |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 296 | except: |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 297 | traceback.print_exc() |
| 298 | slivercount = 0 |
| 299 | sitecount = 0 |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 300 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 301 | userSliceInfo.append({'slicename': slicename, 'sliceid':sliceid, |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 302 | 'sitesUsed':sites_used, |
| 303 | 'role': SliceRole.objects.get(id=entry.role.id).role, |
| 304 | 'slivercount': slivercount, |
| 305 | 'sitecount':sitecount}) |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 306 | |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 307 | return userSliceInfo |
| 308 | |
Scott Baker | e9f4ec9 | 2014-04-29 11:29:45 -0700 | [diff] [blame] | 309 | def getCDNContentProviderData(): |
| 310 | cps = [] |
| 311 | for dm_cp in ContentProvider.objects.all(): |
| 312 | cp = {"name": dm_cp.name, |
| 313 | "account": dm_cp.account} |
| 314 | cps.append(cp) |
| 315 | |
| 316 | return cps |
| 317 | |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 318 | def getCDNOperatorData(randomizeData = False, wait=True): |
| 319 | HPC_SLICE_NAME = "HyperCache" |
| 320 | |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 321 | bq = PlanetStackAnalytics() |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 322 | |
Scott Baker | 4a4472d | 2014-05-13 17:07:46 -0700 | [diff] [blame] | 323 | rows = bq.get_cached_query_results(bq.compose_cached_query(), wait) |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 324 | |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 325 | # wait=False on the first time the Dashboard is opened. This means we might |
| 326 | # not have any rows yet. The dashboard code polls every 30 seconds, so it |
| 327 | # will eventually pick them up. |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 328 | |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 329 | if rows: |
Scott Baker | 696e266 | 2014-04-24 17:03:29 -0700 | [diff] [blame] | 330 | rows = bq.postprocess_results(rows, filter={"event": "hpc_heartbeat"}, maxi=["cpu"], count=["hostname"], computed=["bytes_sent/elapsed"], groupBy=["Time","site"], maxDeltaTime=80) |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 331 | |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 332 | # dictionaryize the statistics rows by site name |
| 333 | stats_rows = {} |
| 334 | for row in rows: |
| 335 | stats_rows[row["site"]] = row |
Scott Baker | edf2f67 | 2014-04-22 10:17:37 -0700 | [diff] [blame] | 336 | else: |
| 337 | stats_rows = {} |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 338 | |
Scott Baker | 09fad02 | 2014-04-30 09:50:01 -0700 | [diff] [blame] | 339 | slice = Slice.objects.filter(name=HPC_SLICE_NAME) |
| 340 | if slice: |
| 341 | slice_slivers = list(slice[0].slivers.all()) |
| 342 | else: |
| 343 | slice_slivers = [] |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 344 | |
| 345 | new_rows = {} |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 346 | for site in Site.objects.all(): |
| 347 | # compute number of slivers allocated in the data model |
| 348 | allocated_slivers = 0 |
| 349 | for sliver in slice_slivers: |
| 350 | if sliver.node.site == site: |
| 351 | allocated_slivers = allocated_slivers + 1 |
| 352 | |
| 353 | stats_row = stats_rows.get(site.name,{}) |
| 354 | |
| 355 | max_cpu = stats_row.get("max_avg_cpu", stats_row.get("max_cpu",0)) |
| 356 | cpu=float(max_cpu)/100.0 |
| 357 | hotness = max(0.0, ((cpu*RED_LOAD) - BLUE_LOAD)/(RED_LOAD-BLUE_LOAD)) |
| 358 | |
| 359 | # format it to what that CDN Operations View is expecting |
| 360 | new_row = {"lat": float(site.location.longitude), |
| 361 | "long": float(site.location.longitude), |
| 362 | "lat": float(site.location.latitude), |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 363 | "health": 0, |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 364 | "numNodes": int(site.nodes.count()), |
Scott Baker | e9f4ec9 | 2014-04-29 11:29:45 -0700 | [diff] [blame] | 365 | "activeHPCSlivers": int(stats_row.get("count_hostname", 0)), # measured number of slivers, from bigquery statistics |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 366 | "numHPCSlivers": allocated_slivers, # allocated number of slivers, from data model |
| 367 | "siteUrl": str(site.site_url), |
| 368 | "bandwidth": stats_row.get("sum_computed_bytes_sent_div_elapsed",0), |
| 369 | "load": max_cpu, |
| 370 | "hot": float(hotness)} |
| 371 | new_rows[str(site.name)] = new_row |
| 372 | |
| 373 | # get rid of sites with 0 slivers that overlap other sites with >0 slivers |
| 374 | for (k,v) in new_rows.items(): |
| 375 | bad=False |
| 376 | if v["numHPCSlivers"]==0: |
| 377 | for v2 in new_rows.values(): |
| 378 | if (v!=v2) and (v2["numHPCSlivers"]>=0): |
| 379 | d = haversine(v["lat"],v["long"],v2["lat"],v2["long"]) |
| 380 | if d<100: |
| 381 | bad=True |
| 382 | if bad: |
| 383 | del new_rows[k] |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 384 | |
| 385 | return new_rows |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 386 | |
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 387 | def getPageSummary(request): |
| 388 | slice = request.GET.get('slice', None) |
| 389 | site = request.GET.get('site', None) |
| 390 | node = request.GET.get('node', None) |
| 391 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 392 | class SimulatorView(View): |
| 393 | def get(self, request, **kwargs): |
| 394 | sim = json.loads(file("/tmp/simulator.json","r").read()) |
| 395 | text = "<html><head></head><body>" |
| 396 | text += "Iteration: %d<br>" % sim["iteration"] |
| 397 | text += "Elapsed since report %d<br><br>" % sim["elapsed_since_report"] |
| 398 | text += "<table border=1>" |
| 399 | text += "<tr><th>site</th><th>trend</th><th>weight</th><th>bytes_sent</th><th>hot</th></tr>" |
| 400 | for site in sim["site_load"].values(): |
| 401 | text += "<tr>" |
| 402 | text += "<td>%s</td><td>%0.2f</td><td>%0.2f</td><td>%d</td><td>%0.2f</td>" % \ |
| 403 | (site["name"], site["trend"], site["weight"], site["bytes_sent"], site["load_frac"]) |
| 404 | text += "</tr>" |
| 405 | text += "</table>" |
| 406 | text += "</body></html>" |
| 407 | return HttpResponse(text) |
| 408 | |
| 409 | class DashboardUserSiteView(View): |
| 410 | def get(self, request, **kwargs): |
| 411 | return HttpResponse(json.dumps(getUserSliceInfo(request.user, True)), mimetype='application/javascript') |
| 412 | |
Scott Baker | 537d823 | 2014-04-08 23:40:56 -0700 | [diff] [blame] | 413 | class TenantViewData(View): |
| 414 | def get(self, request, **kwargs): |
| 415 | return HttpResponse(json.dumps(getTenantSliceInfo(request.user, True)), mimetype='application/javascript') |
| 416 | |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 417 | def haversine(site_lat, site_lon, lat, lon): |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 418 | d=0 |
| 419 | if lat and lon and site_lat and site_lon: |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 420 | site_lat = float(site_lat) |
| 421 | site_lon = float(site_lon) |
| 422 | lat = float(lat) |
| 423 | lon = float(lon) |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 424 | R = 6378.1 |
| 425 | a = math.sin( math.radians((lat - site_lat)/2.0) )**2 + math.cos( math.radians(lat) )*math.cos( math.radians(site_lat) )*(math.sin( math.radians((lon - site_lon)/2.0 ) )**2) |
| 426 | c = 2 * math.atan2( math.sqrt(a), math.sqrt(1 - a) ) |
| 427 | d = R * c |
| 428 | |
| 429 | return d |
| 430 | |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 431 | def siteSortKey(site, slice=None, count=None, lat=None, lon=None): |
| 432 | # try to pick a site we're already using |
| 433 | has_slivers_here=False |
| 434 | if slice: |
| 435 | for sliver in slice.slivers.all(): |
| 436 | if sliver.node.site.name == site.name: |
| 437 | has_slivers_here=True |
| 438 | |
| 439 | # Haversine method |
Scott Baker | 75095b6 | 2014-04-21 17:32:09 -0700 | [diff] [blame] | 440 | d = haversine(site.location.latitude, site.location.longitude, lat, lon) |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 441 | |
| 442 | return (-has_slivers_here, d) |
| 443 | |
| 444 | def tenant_pick_sites(user, user_ip=None, slice=None, count=None): |
| 445 | """ Returns list of sites, sorted from most favorable to least favorable """ |
| 446 | lat=None |
| 447 | lon=None |
| 448 | try: |
| 449 | client_geo = GeoIP().city(user_ip) |
| 450 | if client_geo: |
| 451 | lat=float(client_geo["latitude"]) |
| 452 | lon=float(client_geo["longitude"]) |
| 453 | except: |
| 454 | print "exception in geo code" |
| 455 | traceback.print_exc() |
| 456 | |
| 457 | sites = Site.objects.all() |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 458 | sites = [x for x in sites if x.name in BLESSED_SITES] |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 459 | sites = sorted(sites, key=functools.partial(siteSortKey, slice=slice, count=count, lat=lat, lon=lon)) |
| 460 | |
| 461 | return sites |
| 462 | |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 463 | def slice_increase_slivers(user, user_ip, siteList, slice, count, noAct=False): |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 464 | sitesChanged = {} |
| 465 | |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 466 | # let's compute how many slivers are in use in each node of each site |
| 467 | for site in siteList: |
| 468 | site.nodeList = list(site.nodes.all()) |
| 469 | for node in site.nodeList: |
| 470 | node.sliverCount = 0 |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 471 | for sliver in node.slivers.all(): |
Scott Baker | 2151194 | 2014-04-15 17:44:27 -0700 | [diff] [blame] | 472 | if sliver.slice.id == slice.id: |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 473 | node.sliverCount = node.sliverCount + 1 |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 474 | |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 475 | # Allocate slivers to nodes |
| 476 | # for now, assume we want to allocate all slivers from the same site |
| 477 | nodes = siteList[0].nodeList |
| 478 | while (count>0): |
| 479 | # Sort the node list by number of slivers per node, then pick the |
| 480 | # node with the least number of slivers. |
| 481 | nodes = sorted(nodes, key=attrgetter("sliverCount")) |
| 482 | node = nodes[0] |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 483 | |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 484 | print "adding sliver at node", node.name, "of site", node.site.name |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 485 | |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 486 | if not noAct: |
| 487 | sliver = Sliver(name=node.name, |
| 488 | slice=slice, |
| 489 | node=node, |
| 490 | image = Image.objects.all()[0], |
| 491 | creator = User.objects.get(email=user), |
| 492 | deploymentNetwork=node.deployment, |
| 493 | numberCores =1 ) |
| 494 | sliver.save() |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 495 | |
| 496 | node.sliverCount = node.sliverCount + 1 |
| 497 | |
| 498 | count = count - 1 |
| 499 | |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 500 | sitesChanged[node.site.name] = sitesChanged.get(node.site.name,0) + 1 |
| 501 | |
| 502 | return sitesChanged |
| 503 | |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 504 | def slice_decrease_slivers(user, siteList, slice, count, noAct=False): |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 505 | sitesChanged = {} |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 506 | sliverList ={} |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 507 | if siteList: |
| 508 | siteNames = [site.name for site in siteList] |
| 509 | else: |
| 510 | siteNames = None |
| 511 | |
| 512 | for sliver in slice.slivers.all(): |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 513 | if(not siteNames) or (sliver.node.site.name in siteNames):
|
| 514 | node = sliver.node
|
| 515 | sliverList[sliver.name]=node.name |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 516 | |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 517 | for key in sliverList: |
| 518 | if count>0: |
Scott Baker | f1b65c0 | 2014-04-21 01:03:17 -0700 | [diff] [blame] | 519 | sliver = Sliver.objects.filter(name=key)[0]
|
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 520 | sliver.delete()
|
| 521 | print "deleting sliver",sliverList[key],"at node",sliver.node.name
|
| 522 | count=count-1
|
Scott Baker | f1b65c0 | 2014-04-21 01:03:17 -0700 | [diff] [blame] | 523 | sitesChanged[sliver.node.site.name] = sitesChanged.get(sliver.node.site.name,0) - 1
|
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 524 |
|
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 525 | return sitesChanged |
| 526 | |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 527 | class TenantDeleteSliceView(View): |
| 528 | def post(self,request):
|
| 529 | sliceName = request.POST.get("sliceName",None)
|
| 530 | slice = Slice.objects.get(name=sliceName)
|
Scott Baker | 168b741 | 2014-05-16 14:25:41 -0700 | [diff] [blame] | 531 | #print slice, slice.id
|
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 532 | sliceToDel=Slice(name=sliceName, id=slice.id)
|
| 533 | sliceToDel.delete() |
Scott Baker | 4b0cedd | 2014-04-22 21:01:21 -0700 | [diff] [blame] | 534 | return HttpResponse("Slice deleted") |
Scott Baker | b85c26b | 2014-04-18 11:25:32 -0700 | [diff] [blame] | 535 | |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 536 | class TenantAddOrRemoveSliverView(View): |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 537 | """ Add or remove slivers from a Slice |
| 538 | |
| 539 | Arguments: |
| 540 | siteName - name of site. If not specified, PlanetStack will pick the |
| 541 | best site., |
| 542 | actionToDo - [add | rem] |
| 543 | count - number of slivers to add or remove |
| 544 | sliceName - name of slice |
Scott Baker | a880bb5 | 2014-04-14 23:52:48 -0700 | [diff] [blame] | 545 | noAct - if set, no changes will be made to db, but result will still |
| 546 | show which sites would have been modified. |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 547 | |
| 548 | Returns: |
| 549 | Dictionary of sites that were modified, and the count of nodes |
| 550 | that were added or removed at each site. |
| 551 | """ |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 552 | def post(self, request, *args, **kwargs): |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 553 | siteName = request.POST.get("siteName", None) |
| 554 | actionToDo = request.POST.get("actionToDo", None) |
| 555 | count = int(request.POST.get("count","0")) |
| 556 | sliceName = request.POST.get("slice", None) |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 557 | noAct = request.POST.get("noAct", False) |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 558 | |
| 559 | if not sliceName: |
| 560 | return HttpResponseServerError("No slice name given") |
| 561 | |
| 562 | slice = Slice.objects.get(name=sliceName) |
| 563 | |
| 564 | if siteName: |
| 565 | siteList = [Site.objects.get(name=siteName)] |
| 566 | else: |
| 567 | siteList = None |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 568 | |
| 569 | if (actionToDo == "add"): |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 570 | user_ip = request.GET.get("ip", get_ip(request)) |
| 571 | if (siteList is None): |
| 572 | siteList = tenant_pick_sites(user, user_ip, slice, count) |
| 573 | |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 574 | sitesChanged = slice_increase_slivers(request.user, user_ip, siteList, slice, count, noAct) |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 575 | elif (actionToDo == "rem"): |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 576 | sitesChanged = slice_decrease_slivers(request.user, siteList, slice, count, noAct) |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 577 | else: |
| 578 | return HttpResponseServerError("Unknown actionToDo %s" % actionToDo) |
| 579 | |
Scott Baker | e4deddd | 2014-04-14 16:48:05 -0700 | [diff] [blame] | 580 | return HttpResponse(json.dumps(sitesChanged), mimetype='application/javascript') |
Scott Baker | bd57a43 | 2014-04-14 16:12:15 -0700 | [diff] [blame] | 581 | |
| 582 | def get(self, request, *args, **kwargs): |
| 583 | request.POST = request.GET |
| 584 | return self.post(request, *args, **kwargs) # for testing REST in browser |
| 585 | #return HttpResponseServerError("GET is not supported") |
| 586 | |
| 587 | class TenantPickSitesView(View): |
| 588 | """ primarily just for testing purposes """ |
| 589 | def get(self, request, *args, **kwargs): |
| 590 | count = request.GET.get("count","0") |
| 591 | slice = request.GET.get("slice",None) |
| 592 | if slice: |
| 593 | slice = Slice.objects.get(name=slice) |
| 594 | ip = request.GET.get("ip", get_ip(request)) |
| 595 | sites = tenant_pick_sites(request.user, user_ip=ip, count=0, slice=slice) |
| 596 | sites = [x.name for x in sites] |
| 597 | return HttpResponse(json.dumps(sites), mimetype='application/javascript') |
Scott Baker | 6253dfc | 2014-04-14 09:29:30 -0700 | [diff] [blame] | 598 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 599 | class DashboardSummaryAjaxView(View): |
| 600 | def get(self, request, **kwargs): |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 601 | def avg(x): |
Scott Baker | 111702b | 2014-05-15 16:17:16 -0700 | [diff] [blame] | 602 | if len(x)==0: |
| 603 | return 0 |
Scott Baker | 0017c10 | 2014-04-18 10:48:31 -0700 | [diff] [blame] | 604 | return float(sum(x))/len(x) |
| 605 | |
| 606 | sites = getCDNOperatorData().values() |
| 607 | |
| 608 | sites = [site for site in sites if site["numHPCSlivers"]>0] |
| 609 | |
| 610 | total_slivers = sum( [site["numHPCSlivers"] for site in sites] ) |
| 611 | total_bandwidth = sum( [site["bandwidth"] for site in sites] ) |
| 612 | average_cpu = int(avg( [site["load"] for site in sites] )) |
| 613 | |
| 614 | result= {"total_slivers": total_slivers, |
| 615 | "total_bandwidth": total_bandwidth, |
| 616 | "average_cpu": average_cpu} |
| 617 | |
| 618 | return HttpResponse(json.dumps(result), mimetype='application/javascript') |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 619 | |
| 620 | class DashboardAddOrRemoveSliverView(View): |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 621 | # TODO: deprecate this view in favor of using TenantAddOrRemoveSliverView |
| 622 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 623 | def post(self, request, *args, **kwargs): |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 624 | siteName = request.POST.get("site", None) |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 625 | actionToDo = request.POST.get("actionToDo", "0") |
| 626 | |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 627 | siteList = [Site.objects.get(name=siteName)] |
| 628 | slice = Slice.objects.get(name="HyperCache") |
| 629 | |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 630 | if (actionToDo == "add"): |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 631 | user_ip = request.GET.get("ip", get_ip(request)) |
| 632 | slice_increase_slivers(request.user, user_ip, siteList, slice, 1) |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 633 | elif (actionToDo == "rem"): |
Scott Baker | fe6a7e1 | 2014-04-15 10:58:31 -0700 | [diff] [blame] | 634 | slice_decrease_slivers(request.user, siteList, slice, 1) |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 635 | |
| 636 | print '*' * 50 |
| 637 | print 'Ask for site: ' + siteName + ' to ' + actionToDo + ' another HPC Sliver' |
| 638 | return HttpResponse('This is POST request ') |
Siobhan Tully | 06d2c03 | 2014-02-23 23:48:52 -0500 | [diff] [blame] | 639 | |
| 640 | class DashboardAjaxView(View): |
| 641 | def get(self, request, **kwargs): |
| 642 | return HttpResponse(json.dumps(getCDNOperatorData(True)), mimetype='application/javascript') |
Scott Baker | 771819b | 2014-03-19 22:10:17 -0700 | [diff] [blame] | 643 | |
| 644 | class DashboardAnalyticsAjaxView(View): |
| 645 | def get(self, request, name="hello_world", **kwargs): |
| 646 | if (name == "hpcSummary"): |
| 647 | return HttpResponse(json.dumps(hpc_wizard.get_hpc_wizard().get_summary_for_view()), mimetype='application/javascript') |
| 648 | elif (name == "hpcUserSite"): |
| 649 | return HttpResponse(json.dumps(getUserSliceInfo(request.user, True)), mimetype='application/javascript') |
| 650 | elif (name == "hpcMap"): |
| 651 | return HttpResponse(json.dumps(getCDNOperatorData(True)), mimetype='application/javascript') |
| 652 | elif (name == "bigquery"): |
| 653 | (mimetype, data) = DoPlanetStackAnalytics(request) |
| 654 | return HttpResponse(data, mimetype=mimetype) |
| 655 | else: |
| 656 | return HttpResponse(json.dumps("Unknown"), mimetype='application/javascript') |
| 657 | |