Revision 4b3b8688
| b/snf-cyclades-app/synnefo/api/actions.py | ||
|---|---|---|
| 296 | 296 |
server_id = args.get('serverRef', None)
|
| 297 | 297 |
if not server_id: |
| 298 | 298 |
raise BadRequest('Malformed Request.')
|
| 299 |
vm = get_vm(server_id, request.user) |
|
| 299 |
vm = get_vm(server_id, request.user_uniq)
|
|
| 300 | 300 |
backend.connect_to_network(vm, net) |
| 301 | 301 |
vm.save() |
| 302 | 302 |
net.save() |
| ... | ... | |
| 316 | 316 |
server_id = args.get('serverRef', None)
|
| 317 | 317 |
if not server_id: |
| 318 | 318 |
raise BadRequest('Malformed Request.')
|
| 319 |
vm = get_vm(server_id, request.user) |
|
| 319 |
vm = get_vm(server_id, request.user_uniq)
|
|
| 320 | 320 |
backend.disconnect_from_network(vm, net) |
| 321 | 321 |
vm.save() |
| 322 | 322 |
net.save() |
| b/snf-cyclades-app/synnefo/api/images.py | ||
|---|---|---|
| 114 | 114 |
# overLimit (413) |
| 115 | 115 |
|
| 116 | 116 |
log.debug('list_images detail=%s', detail)
|
| 117 |
backend = ImageBackend(request.user) |
|
| 117 |
backend = ImageBackend(request.user_uniq)
|
|
| 118 | 118 |
|
| 119 | 119 |
since = isoparse(request.GET.get('changes-since'))
|
| 120 | 120 |
if since: |
| ... | ... | |
| 168 | 168 |
# overLimit (413) |
| 169 | 169 |
|
| 170 | 170 |
log.debug('get_image_details %s', image_id)
|
| 171 |
image = util.get_image(image_id, request.user) |
|
| 171 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 172 | 172 |
reply = image_to_dict(image) |
| 173 | 173 |
|
| 174 | 174 |
if request.serialization == 'xml': |
| ... | ... | |
| 189 | 189 |
# overLimit (413) |
| 190 | 190 |
|
| 191 | 191 |
log.debug('delete_image %s', image_id)
|
| 192 |
backend = ImageBackend(request.user) |
|
| 192 |
backend = ImageBackend(request.user_uniq)
|
|
| 193 | 193 |
backend.delete(image_id) |
| 194 | 194 |
backend.close() |
| 195 |
log.info('User %s deleted image %s', request.user, image_id)
|
|
| 195 |
log.info('User %s deleted image %s', request.user_uniq, image_id)
|
|
| 196 | 196 |
return HttpResponse(status=204) |
| 197 | 197 |
|
| 198 | 198 |
|
| ... | ... | |
| 206 | 206 |
# overLimit (413) |
| 207 | 207 |
|
| 208 | 208 |
log.debug('list_image_metadata %s', image_id)
|
| 209 |
image = util.get_image(image_id, request.user) |
|
| 209 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 210 | 210 |
metadata = image['properties'] |
| 211 | 211 |
return util.render_metadata(request, metadata, use_values=True, status=200) |
| 212 | 212 |
|
| ... | ... | |
| 224 | 224 |
|
| 225 | 225 |
req = util.get_request_dict(request) |
| 226 | 226 |
log.debug('update_image_metadata %s %s', image_id, req)
|
| 227 |
image = util.get_image(image_id, request.user) |
|
| 227 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 228 | 228 |
try: |
| 229 | 229 |
metadata = req['metadata'] |
| 230 | 230 |
assert isinstance(metadata, dict) |
| ... | ... | |
| 234 | 234 |
properties = image['properties'] |
| 235 | 235 |
properties.update(metadata) |
| 236 | 236 |
|
| 237 |
backend = ImageBackend(request.user) |
|
| 237 |
backend = ImageBackend(request.user_uniq)
|
|
| 238 | 238 |
backend.update(image_id, dict(properties=properties)) |
| 239 | 239 |
backend.close() |
| 240 | 240 |
|
| ... | ... | |
| 252 | 252 |
# overLimit (413) |
| 253 | 253 |
|
| 254 | 254 |
log.debug('get_image_metadata_item %s %s', image_id, key)
|
| 255 |
image = util.get_image(image_id, request.user) |
|
| 255 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 256 | 256 |
val = image['properties'].get(key) |
| 257 | 257 |
if val is None: |
| 258 | 258 |
raise ItemNotFound('Metadata key not found.')
|
| ... | ... | |
| 282 | 282 |
raise BadRequest('Malformed request.')
|
| 283 | 283 |
|
| 284 | 284 |
val = metadict[key] |
| 285 |
image = util.get_image(image_id, request.user) |
|
| 285 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 286 | 286 |
properties = image['properties'] |
| 287 | 287 |
properties[key] = val |
| 288 | 288 |
|
| 289 |
backend = ImageBackend(request.user) |
|
| 289 |
backend = ImageBackend(request.user_uniq)
|
|
| 290 | 290 |
backend.update(image_id, dict(properties=properties)) |
| 291 | 291 |
backend.close() |
| 292 | 292 |
|
| ... | ... | |
| 306 | 306 |
# overLimit (413), |
| 307 | 307 |
|
| 308 | 308 |
log.debug('delete_image_metadata_item %s %s', image_id, key)
|
| 309 |
image = util.get_image(image_id, request.user) |
|
| 309 |
image = util.get_image(image_id, request.user_uniq)
|
|
| 310 | 310 |
properties = image['properties'] |
| 311 | 311 |
properties.pop(key, None) |
| 312 | 312 |
|
| 313 |
backend = ImageBackend(request.user) |
|
| 313 |
backend = ImageBackend(request.user_uniq)
|
|
| 314 | 314 |
backend.update(image_id, dict(properties=properties)) |
| 315 | 315 |
backend.close() |
| 316 | 316 |
|
| /dev/null | ||
|---|---|---|
| 1 |
# Copyright 2012 GRNET S.A. All rights reserved. |
|
| 2 |
# |
|
| 3 |
# Redistribution and use in source and binary forms, with or |
|
| 4 |
# without modification, are permitted provided that the following |
|
| 5 |
# conditions are met: |
|
| 6 |
# |
|
| 7 |
# 1. Redistributions of source code must retain the above |
|
| 8 |
# copyright notice, this list of conditions and the following |
|
| 9 |
# disclaimer. |
|
| 10 |
# |
|
| 11 |
# 2. Redistributions in binary form must reproduce the above |
|
| 12 |
# copyright notice, this list of conditions and the following |
|
| 13 |
# disclaimer in the documentation and/or other materials |
|
| 14 |
# provided with the distribution. |
|
| 15 |
# |
|
| 16 |
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS |
|
| 17 |
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
| 18 |
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
| 19 |
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR |
|
| 20 |
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
| 21 |
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
| 22 |
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
|
| 23 |
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
|
| 24 |
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
| 25 |
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
|
| 26 |
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|
| 27 |
# POSSIBILITY OF SUCH DAMAGE. |
|
| 28 |
# |
|
| 29 |
# The views and conclusions contained in the software and |
|
| 30 |
# documentation are those of the authors and should not be |
|
| 31 |
# interpreted as representing official policies, either expressed |
|
| 32 |
# or implied, of GRNET S.A. |
|
| 33 |
|
|
| 34 |
import json |
|
| 35 |
|
|
| 36 |
from httplib import HTTPConnection, HTTPSConnection |
|
| 37 |
from urlparse import urlparse |
|
| 38 |
|
|
| 39 |
from django.conf import settings |
|
| 40 |
from django.utils.cache import patch_vary_headers |
|
| 41 |
|
|
| 42 |
|
|
| 43 |
class ApiAuthMiddleware(object): |
|
| 44 |
def process_request(self, request): |
|
| 45 |
request.user = None |
|
| 46 |
request.username = '' |
|
| 47 |
|
|
| 48 |
if settings.TEST: |
|
| 49 |
request.user = 'test' |
|
| 50 |
request.username = 'test' |
|
| 51 |
return |
|
| 52 |
|
|
| 53 |
token = request.GET.get('X-Auth-Token')
|
|
| 54 |
if not token: |
|
| 55 |
token = request.META.get('HTTP_X_AUTH_TOKEN')
|
|
| 56 |
if not token: |
|
| 57 |
token = request.COOKIES.get('X-Auth-Token')
|
|
| 58 |
|
|
| 59 |
if not token: |
|
| 60 |
return |
|
| 61 |
|
|
| 62 |
p = urlparse(settings.ASTAKOS_URL) |
|
| 63 |
if p.scheme == 'https': |
|
| 64 |
conn = HTTPSConnection(p.netloc) |
|
| 65 |
else: |
|
| 66 |
conn = HTTPConnection(p.netloc) |
|
| 67 |
|
|
| 68 |
headers = {'X-Auth-Token': token}
|
|
| 69 |
conn.request('GET', p.path, headers=headers)
|
|
| 70 |
resp = conn.getresponse() |
|
| 71 |
if resp.status != 200: |
|
| 72 |
return |
|
| 73 |
|
|
| 74 |
try: |
|
| 75 |
reply = json.loads(resp.read()) |
|
| 76 |
assert 'uniq' in reply |
|
| 77 |
assert 'username' in reply |
|
| 78 |
except (ValueError, AssertionError): |
|
| 79 |
return |
|
| 80 |
|
|
| 81 |
request.user = reply['uniq'] |
|
| 82 |
request.username = reply['username'] |
|
| 83 |
|
|
| 84 |
def process_response(self, request, response): |
|
| 85 |
# Tell proxies and other interested parties that the request varies |
|
| 86 |
# based on X-Auth-Token, to avoid caching of results |
|
| 87 |
patch_vary_headers(response, ('X-Auth-Token',))
|
|
| 88 |
return response |
|
| b/snf-cyclades-app/synnefo/api/networks.py | ||
|---|---|---|
| 110 | 110 |
log.debug('list_networks detail=%s', detail)
|
| 111 | 111 |
since = util.isoparse(request.GET.get('changes-since'))
|
| 112 | 112 |
user_networks = Network.objects.filter( |
| 113 |
Q(userid=request.user) | Q(public=True))
|
|
| 113 |
Q(userid=request.user_uniq) | Q(public=True))
|
|
| 114 | 114 |
|
| 115 | 115 |
if since: |
| 116 | 116 |
user_networks = user_networks.filter(updated__gte=since) |
| ... | ... | |
| 119 | 119 |
else: |
| 120 | 120 |
user_networks = user_networks.filter(state='ACTIVE') |
| 121 | 121 |
|
| 122 |
networks = [network_to_dict(network, request.user, detail) |
|
| 122 |
networks = [network_to_dict(network, request.user_uniq, detail)
|
|
| 123 | 123 |
for network in user_networks] |
| 124 | 124 |
|
| 125 | 125 |
if request.serialization == 'xml': |
| ... | ... | |
| 151 | 151 |
except (KeyError, ValueError): |
| 152 | 152 |
raise BadRequest('Malformed request.')
|
| 153 | 153 |
|
| 154 |
network = backend.create_network(name, request.user) |
|
| 154 |
network = backend.create_network(name, request.user_uniq)
|
|
| 155 | 155 |
if not network: |
| 156 | 156 |
raise OverLimit('Network count limit exceeded for your account.')
|
| 157 | 157 |
|
| 158 |
networkdict = network_to_dict(network, request.user) |
|
| 158 |
networkdict = network_to_dict(network, request.user_uniq)
|
|
| 159 | 159 |
return render_network(request, networkdict, status=202) |
| 160 | 160 |
|
| 161 | 161 |
|
| ... | ... | |
| 170 | 170 |
# overLimit (413) |
| 171 | 171 |
|
| 172 | 172 |
log.debug('get_network_details %s', network_id)
|
| 173 |
net = util.get_network(network_id, request.user) |
|
| 174 |
netdict = network_to_dict(net, request.user) |
|
| 173 |
net = util.get_network(network_id, request.user_uniq)
|
|
| 174 |
netdict = network_to_dict(net, request.user_uniq)
|
|
| 175 | 175 |
return render_network(request, netdict) |
| 176 | 176 |
|
| 177 | 177 |
|
| ... | ... | |
| 194 | 194 |
except (TypeError, KeyError): |
| 195 | 195 |
raise BadRequest('Malformed request.')
|
| 196 | 196 |
|
| 197 |
net = util.get_network(network_id, request.user) |
|
| 197 |
net = util.get_network(network_id, request.user_uniq)
|
|
| 198 | 198 |
if net.public: |
| 199 | 199 |
raise Unauthorized('Can not rename the public network.')
|
| 200 | 200 |
net.name = name |
| ... | ... | |
| 213 | 213 |
# overLimit (413) |
| 214 | 214 |
|
| 215 | 215 |
log.debug('delete_network %s', network_id)
|
| 216 |
net = util.get_network(network_id, request.user) |
|
| 216 |
net = util.get_network(network_id, request.user_uniq)
|
|
| 217 | 217 |
if net.public: |
| 218 | 218 |
raise Unauthorized('Can not delete the public network.')
|
| 219 | 219 |
backend.delete_network(net) |
| ... | ... | |
| 227 | 227 |
if len(req) != 1: |
| 228 | 228 |
raise BadRequest('Malformed request.')
|
| 229 | 229 |
|
| 230 |
net = util.get_network(network_id, request.user) |
|
| 230 |
net = util.get_network(network_id, request.user_uniq)
|
|
| 231 | 231 |
if net.public: |
| 232 | 232 |
raise Unauthorized('Can not modify the public network.')
|
| 233 | 233 |
|
| b/snf-cyclades-app/synnefo/api/servers.py | ||
|---|---|---|
| 161 | 161 |
# overLimit (413) |
| 162 | 162 |
|
| 163 | 163 |
log.debug('list_servers detail=%s', detail)
|
| 164 |
user_vms = VirtualMachine.objects.filter(userid=request.user) |
|
| 164 |
user_vms = VirtualMachine.objects.filter(userid=request.user_uniq)
|
|
| 165 | 165 |
since = util.isoparse(request.GET.get('changes-since'))
|
| 166 | 166 |
|
| 167 | 167 |
if since: |
| ... | ... | |
| 230 | 230 |
raise faults.BadRequest("Malformed personality in request")
|
| 231 | 231 |
|
| 232 | 232 |
image = {}
|
| 233 |
img = util.get_image(image_id, request.user) |
|
| 233 |
img = util.get_image(image_id, request.user_uniq)
|
|
| 234 | 234 |
properties = img.get('properties', {})
|
| 235 | 235 |
image['backend_id'] = img['location'] |
| 236 | 236 |
image['format'] = img['disk_format'] |
| ... | ... | |
| 240 | 240 |
flavor = util.get_flavor(flavor_id) |
| 241 | 241 |
password = util.random_password() |
| 242 | 242 |
|
| 243 |
count = VirtualMachine.objects.filter(userid=request.user, |
|
| 243 |
count = VirtualMachine.objects.filter(userid=request.user_uniq,
|
|
| 244 | 244 |
deleted=False).count() |
| 245 | 245 |
if count >= settings.MAX_VMS_PER_USER: |
| 246 | 246 |
raise faults.OverLimit("Server count limit exceeded for your account.")
|
| ... | ... | |
| 248 | 248 |
# We must save the VM instance now, so that it gets a valid vm.backend_id. |
| 249 | 249 |
vm = VirtualMachine.objects.create( |
| 250 | 250 |
name=name, |
| 251 |
userid=request.user, |
|
| 251 |
userid=request.user_uniq,
|
|
| 252 | 252 |
imageid=image_id, |
| 253 | 253 |
flavor=flavor) |
| 254 | 254 |
|
| ... | ... | |
| 265 | 265 |
vm=vm) |
| 266 | 266 |
|
| 267 | 267 |
log.info('User %s created vm with %s cpus, %s ram and %s storage',
|
| 268 |
request.user, flavor.cpu, flavor.ram, flavor.disk) |
|
| 268 |
request.user_uniq, flavor.cpu, flavor.ram, flavor.disk)
|
|
| 269 | 269 |
|
| 270 | 270 |
server = vm_to_dict(vm, detail=True) |
| 271 | 271 |
server['status'] = 'BUILD' |
| ... | ... | |
| 284 | 284 |
# overLimit (413) |
| 285 | 285 |
|
| 286 | 286 |
log.debug('get_server_details %s', server_id)
|
| 287 |
vm = util.get_vm(server_id, request.user) |
|
| 287 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 288 | 288 |
server = vm_to_dict(vm, detail=True) |
| 289 | 289 |
return render_server(request, server) |
| 290 | 290 |
|
| ... | ... | |
| 309 | 309 |
except (TypeError, KeyError): |
| 310 | 310 |
raise faults.BadRequest("Malformed request")
|
| 311 | 311 |
|
| 312 |
vm = util.get_vm(server_id, request.user) |
|
| 312 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 313 | 313 |
vm.name = name |
| 314 | 314 |
vm.save() |
| 315 | 315 |
|
| ... | ... | |
| 328 | 328 |
# overLimit (413) |
| 329 | 329 |
|
| 330 | 330 |
log.debug('delete_server %s', server_id)
|
| 331 |
vm = util.get_vm(server_id, request.user) |
|
| 331 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 332 | 332 |
delete_instance(vm) |
| 333 | 333 |
return HttpResponse(status=204) |
| 334 | 334 |
|
| ... | ... | |
| 337 | 337 |
def server_action(request, server_id): |
| 338 | 338 |
req = util.get_request_dict(request) |
| 339 | 339 |
log.debug('server_action %s %s', server_id, req)
|
| 340 |
vm = util.get_vm(server_id, request.user) |
|
| 340 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 341 | 341 |
if len(req) != 1: |
| 342 | 342 |
raise faults.BadRequest("Malformed request")
|
| 343 | 343 |
|
| ... | ... | |
| 363 | 363 |
# overLimit (413) |
| 364 | 364 |
|
| 365 | 365 |
log.debug('list_addresses %s', server_id)
|
| 366 |
vm = util.get_vm(server_id, request.user) |
|
| 366 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 367 | 367 |
addresses = [nic_to_dict(nic) for nic in vm.nics.all()] |
| 368 | 368 |
|
| 369 | 369 |
if request.serialization == 'xml': |
| ... | ... | |
| 385 | 385 |
# overLimit (413) |
| 386 | 386 |
|
| 387 | 387 |
log.debug('list_addresses_by_network %s %s', server_id, network_id)
|
| 388 |
machine = util.get_vm(server_id, request.user) |
|
| 389 |
network = util.get_network(network_id, request.user) |
|
| 388 |
machine = util.get_vm(server_id, request.user_uniq)
|
|
| 389 |
network = util.get_network(network_id, request.user_uniq)
|
|
| 390 | 390 |
nic = util.get_nic(machine, network) |
| 391 | 391 |
address = nic_to_dict(nic) |
| 392 | 392 |
|
| ... | ... | |
| 408 | 408 |
# overLimit (413) |
| 409 | 409 |
|
| 410 | 410 |
log.debug('list_server_metadata %s', server_id)
|
| 411 |
vm = util.get_vm(server_id, request.user) |
|
| 411 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 412 | 412 |
metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all()) |
| 413 | 413 |
return util.render_metadata(request, metadata, use_values=True, status=200) |
| 414 | 414 |
|
| ... | ... | |
| 426 | 426 |
|
| 427 | 427 |
req = util.get_request_dict(request) |
| 428 | 428 |
log.debug('update_server_metadata %s %s', server_id, req)
|
| 429 |
vm = util.get_vm(server_id, request.user) |
|
| 429 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 430 | 430 |
try: |
| 431 | 431 |
metadata = req['metadata'] |
| 432 | 432 |
assert isinstance(metadata, dict) |
| ... | ... | |
| 454 | 454 |
# overLimit (413) |
| 455 | 455 |
|
| 456 | 456 |
log.debug('get_server_metadata_item %s %s', server_id, key)
|
| 457 |
vm = util.get_vm(server_id, request.user) |
|
| 457 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 458 | 458 |
meta = util.get_vm_meta(vm, key) |
| 459 | 459 |
d = {meta.meta_key: meta.meta_value}
|
| 460 | 460 |
return util.render_meta(request, d, status=200) |
| ... | ... | |
| 474 | 474 |
|
| 475 | 475 |
req = util.get_request_dict(request) |
| 476 | 476 |
log.debug('create_server_metadata_item %s %s %s', server_id, key, req)
|
| 477 |
vm = util.get_vm(server_id, request.user) |
|
| 477 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 478 | 478 |
try: |
| 479 | 479 |
metadict = req['meta'] |
| 480 | 480 |
assert isinstance(metadict, dict) |
| ... | ... | |
| 507 | 507 |
# overLimit (413), |
| 508 | 508 |
|
| 509 | 509 |
log.debug('delete_server_metadata_item %s %s', server_id, key)
|
| 510 |
vm = util.get_vm(server_id, request.user) |
|
| 510 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 511 | 511 |
meta = util.get_vm_meta(vm, key) |
| 512 | 512 |
meta.delete() |
| 513 | 513 |
vm.save() |
| ... | ... | |
| 525 | 525 |
# overLimit (413) |
| 526 | 526 |
|
| 527 | 527 |
log.debug('server_stats %s', server_id)
|
| 528 |
vm = util.get_vm(server_id, request.user) |
|
| 528 |
vm = util.get_vm(server_id, request.user_uniq)
|
|
| 529 | 529 |
#secret = util.encrypt(vm.backend_id) |
| 530 | 530 |
secret = vm.backend_id # XXX disable backend id encryption |
| 531 | 531 |
|
| b/snf-cyclades-app/synnefo/api/util.py | ||
|---|---|---|
| 58 | 58 |
ItemNotFound, ServiceUnavailable, Unauthorized) |
| 59 | 59 |
from synnefo.db.models import (Flavor, VirtualMachine, VirtualMachineMetadata, |
| 60 | 60 |
Network, NetworkInterface) |
| 61 |
from synnefo.lib.astakos import get_user |
|
| 61 | 62 |
from synnefo.plankton.backend import ImageBackend |
| 62 | 63 |
|
| 63 | 64 |
|
| ... | ... | |
| 315 | 316 |
try: |
| 316 | 317 |
request.serialization = request_serialization(request, |
| 317 | 318 |
atom_allowed) |
| 318 |
if not request.user: |
|
| 319 |
get_user(request, settings.ASTAKOS_URL) |
|
| 320 |
if not request.user_uniq: |
|
| 319 | 321 |
raise Unauthorized('No user found.')
|
| 320 | 322 |
if http_method and request.method != http_method: |
| 321 | 323 |
raise BadRequest('Method not allowed.')
|
| b/snf-cyclades-app/synnefo/app_settings/__init__.py | ||
|---|---|---|
| 8 | 8 |
'synnefo.ui.userdata', |
| 9 | 9 |
] |
| 10 | 10 |
|
| 11 |
synnefo_web_middleware = [ |
|
| 12 |
{'after': 'django.middleware.locale.LocaleMiddleware', 'insert': [
|
|
| 13 |
'synnefo.api.middleware.ApiAuthMiddleware' |
|
| 14 |
] |
|
| 15 |
} |
|
| 16 |
] |
|
| 11 |
synnefo_web_middleware = [] |
|
| 17 | 12 |
|
| 18 | 13 |
synnefo_static_files = {
|
| 19 | 14 |
'synnefo.ui': 'ui', |
| b/snf-cyclades-app/synnefo/plankton/util.py | ||
|---|---|---|
| 41 | 41 |
from django.http import (HttpResponse, HttpResponseBadRequest, |
| 42 | 42 |
HttpResponseServerError) |
| 43 | 43 |
|
| 44 |
from synnefo.lib.astakos import get_user |
|
| 44 | 45 |
from synnefo.plankton.backend import ImageBackend, BackendException |
| 45 | 46 |
|
| 46 | 47 |
|
| 47 | 48 |
log = getLogger('synnefo.plankton')
|
| 48 | 49 |
|
| 49 | 50 |
|
| 50 |
def get_user_from_token(token): |
|
| 51 |
return None |
|
| 52 |
|
|
| 53 |
|
|
| 54 |
def get_request_user(request): |
|
| 55 |
user = get_user_from_token(request.META.get('HTTP_X_AUTH_TOKEN'))
|
|
| 56 |
if not user: |
|
| 57 |
user = get_user_from_token(request.COOKIES.get('X-Auth-Token'))
|
|
| 58 |
return user |
|
| 59 |
|
|
| 60 |
|
|
| 61 | 51 |
def plankton_method(method): |
| 62 | 52 |
def decorator(func): |
| 63 | 53 |
@wraps(func) |
| 64 | 54 |
def wrapper(request, *args, **kwargs): |
| 65 | 55 |
try: |
| 56 |
get_user(request, settings.ASTAKOS_URL) |
|
| 57 |
if not request.user_uniq: |
|
| 58 |
raise Unauthorized('No user found.')
|
|
| 66 | 59 |
if request.method != method: |
| 67 | 60 |
return HttpResponse(status=405) |
| 68 |
if not request.user: |
|
| 61 |
if not request.user_uniq:
|
|
| 69 | 62 |
return HttpResponse(status=401) |
| 70 |
request.backend = ImageBackend(request.user) |
|
| 63 |
request.backend = ImageBackend(request.user_uniq)
|
|
| 71 | 64 |
return func(request, *args, **kwargs) |
| 72 | 65 |
except (AssertionError, BackendException) as e: |
| 73 | 66 |
message = e.args[0] if e.args else '' |
| b/snf-cyclades-app/synnefo/ui/templates/feedback_mail.txt | ||
|---|---|---|
| 6 | 6 |
|
| 7 | 7 |
User info: |
| 8 | 8 |
ID: {{ request.user.id }}
|
| 9 |
Email: {{ request.user.uniq }}
|
|
| 9 |
Email: {{ request.user_uniq }}
|
|
| 10 | 10 |
|
| 11 | 11 |
User application data: |
| 12 | 12 |
{{ data|safe }}
|
| b/snf-cyclades-app/synnefo/ui/userdata/rest.py | ||
|---|---|---|
| 228 | 228 |
Filter collection queryset for request user entries |
| 229 | 229 |
""" |
| 230 | 230 |
def queryset(self): |
| 231 |
return super(UserCollectionView, self).queryset().filter(user=self.request.user) |
|
| 231 |
return super(UserCollectionView, self).queryset().filter(user=self.request.user_uniq)
|
|
| 232 | 232 |
|
| 233 | 233 |
def POST(self, request, data, *args, **kwargs): |
| 234 | 234 |
instance = self.model() |
Also available in: Unified diff