code.grnet.gr Git - pithos/blob - pithos/api/functions.py

   1 # Copyright 2011 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 os
  35 import logging
  36 import hashlib
  37 import uuid
  38
  39 from django.http import HttpResponse
  40 from django.template.loader import render_to_string
  41 from django.utils import simplejson as json
  42 from django.utils.http import parse_etags
  43
  44 from pithos.api.faults import (Fault, NotModified, BadRequest, Unauthorized, ItemNotFound, Conflict,
  45     LengthRequired, PreconditionFailed, RangeNotSatisfiable, UnprocessableEntity)
  46 from pithos.api.util import (format_meta_key, printable_meta_dict, get_account_meta,
  47     put_account_meta, get_container_meta, put_container_meta, get_object_meta, put_object_meta,
  48     validate_modification_preconditions, validate_matching_preconditions, copy_or_move_object,
  49     get_content_length, get_range, get_content_range, raw_input_socket, socket_read_iterator,
  50     ObjectWrapper, api_method)
  51 from pithos.backends import backend
  52
  53
  54 logger = logging.getLogger(__name__)
  55
  56
  57 def top_demux(request):
  58     if request.method == 'GET':
  59         return authenticate(request)
  60     else:
  61         return method_not_allowed(request)
  62
  63 def account_demux(request, v_account):
  64     if request.method == 'HEAD':
  65         return account_meta(request, v_account)
  66     elif request.method == 'GET':
  67         return container_list(request, v_account)
  68     elif request.method == 'POST':
  69         return account_update(request, v_account)
  70     else:
  71         return method_not_allowed(request)
  72
  73 def container_demux(request, v_account, v_container):
  74     if request.method == 'HEAD':
  75         return container_meta(request, v_account, v_container)
  76     elif request.method == 'GET':
  77         return object_list(request, v_account, v_container)
  78     elif request.method == 'PUT':
  79         return container_create(request, v_account, v_container)
  80     elif request.method == 'POST':
  81         return container_update(request, v_account, v_container)
  82     elif request.method == 'DELETE':
  83         return container_delete(request, v_account, v_container)
  84     else:
  85         return method_not_allowed(request)
  86
  87 def object_demux(request, v_account, v_container, v_object):
  88     if request.method == 'HEAD':
  89         return object_meta(request, v_account, v_container, v_object)
  90     elif request.method == 'GET':
  91         return object_read(request, v_account, v_container, v_object)
  92     elif request.method == 'PUT':
  93         return object_write(request, v_account, v_container, v_object)
  94     elif request.method == 'COPY':
  95         return object_copy(request, v_account, v_container, v_object)
  96     elif request.method == 'MOVE':
  97         return object_move(request, v_account, v_container, v_object)
  98     elif request.method == 'POST':
  99         return object_update(request, v_account, v_container, v_object)
 100     elif request.method == 'DELETE':
 101         return object_delete(request, v_account, v_container, v_object)
 102     else:
 103         return method_not_allowed(request)
 104
 105 @api_method('GET')
 106 def authenticate(request):
 107     # Normal Response Codes: 204
 108     # Error Response Codes: serviceUnavailable (503),
 109     #                       unauthorized (401),
 110     #                       badRequest (400)
 111
 112     x_auth_user = request.META.get('HTTP_X_AUTH_USER')
 113     x_auth_key = request.META.get('HTTP_X_AUTH_KEY')
 114     if not x_auth_user or not x_auth_key:
 115         raise BadRequest('Missing X-Auth-User or X-Auth-Key header')
 116
 117     response = HttpResponse(status=204)
 118     response['X-Auth-Token'] = '0000'
 119     response['X-Storage-Url'] = os.path.join(request.build_absolute_uri(), 'demo')
 120     return response
 121
 122 @api_method('HEAD')
 123 def account_meta(request, v_account):
 124     # Normal Response Codes: 204
 125     # Error Response Codes: serviceUnavailable (503),
 126     #                       unauthorized (401),
 127     #                       badRequest (400)
 128
 129     meta = backend.get_account_meta(request.user)
 130
 131     response = HttpResponse(status=204)
 132     put_account_meta(response, meta)
 133     return response
 134
 135 @api_method('POST')
 136 def account_update(request, v_account):
 137     # Normal Response Codes: 202
 138     # Error Response Codes: serviceUnavailable (503),
 139     #                       unauthorized (401),
 140     #                       badRequest (400)
 141
 142     meta = get_account_meta(request)
 143     backend.update_account_meta(request.user, meta, replace=True)
 144     return HttpResponse(status=202)
 145
 146 @api_method('GET', format_allowed=True)
 147 def container_list(request, v_account):
 148     # Normal Response Codes: 200, 204
 149     # Error Response Codes: serviceUnavailable (503),
 150     #                       itemNotFound (404),
 151     #                       unauthorized (401),
 152     #                       badRequest (400)
 153
 154     meta = backend.get_account_meta(request.user)
 155
 156     validate_modification_preconditions(request, meta)
 157
 158     response = HttpResponse()
 159     put_account_meta(response, meta)
 160
 161     marker = request.GET.get('marker')
 162     limit = request.GET.get('limit')
 163     if limit:
 164         try:
 165             limit = int(limit)
 166             if limit <= 0:
 167                 raise ValueError
 168         except ValueError:
 169             limit = 10000
 170
 171     try:
 172         containers = backend.list_containers(request.user, marker, limit)
 173     except NameError:
 174         containers = []
 175
 176     if request.serialization == 'text':
 177         if len(containers) == 0:
 178             # The cloudfiles python bindings expect 200 if json/xml.
 179             response.status_code = 204
 180             return response
 181         response.status_code = 200
 182         response.content = '\n'.join(containers) + '\n'
 183         return response
 184
 185     container_meta = []
 186     for x in containers:
 187         try:
 188             meta = backend.get_container_meta(request.user, x)
 189         except NameError:
 190             continue
 191         container_meta.append(printable_meta_dict(meta))
 192     if request.serialization == 'xml':
 193         data = render_to_string('containers.xml', {'account': request.user, 'containers': container_meta})
 194     elif request.serialization  == 'json':
 195         data = json.dumps(container_meta)
 196     response.status_code = 200
 197     response.content = data
 198     return response
 199
 200 @api_method('HEAD')
 201 def container_meta(request, v_account, v_container):
 202     # Normal Response Codes: 204
 203     # Error Response Codes: serviceUnavailable (503),
 204     #                       itemNotFound (404),
 205     #                       unauthorized (401),
 206     #                       badRequest (400)
 207
 208     try:
 209         meta = backend.get_container_meta(request.user, v_container)
 210         meta['object_meta'] = backend.list_object_meta(request.user, v_container)
 211     except NameError:
 212         raise ItemNotFound('Container does not exist')
 213
 214     response = HttpResponse(status=204)
 215     put_container_meta(response, meta)
 216     return response
 217
 218 @api_method('PUT')
 219 def container_create(request, v_account, v_container):
 220     # Normal Response Codes: 201, 202
 221     # Error Response Codes: serviceUnavailable (503),
 222     #                       itemNotFound (404),
 223     #                       unauthorized (401),
 224     #                       badRequest (400)
 225
 226     meta = get_container_meta(request)
 227
 228     try:
 229         backend.put_container(request.user, v_container)
 230         ret = 201
 231     except NameError:
 232         ret = 202
 233
 234     if len(meta) > 0:
 235         backend.update_container_meta(request.user, v_container, meta, replace=True)
 236
 237     return HttpResponse(status=ret)
 238
 239 @api_method('POST')
 240 def container_update(request, v_account, v_container):
 241     # Normal Response Codes: 202
 242     # Error Response Codes: serviceUnavailable (503),
 243     #                       itemNotFound (404),
 244     #                       unauthorized (401),
 245     #                       badRequest (400)
 246
 247     meta = get_container_meta(request)
 248     try:
 249         backend.update_container_meta(request.user, v_container, meta, replace=True)
 250     except NameError:
 251         raise ItemNotFound('Container does not exist')
 252     return HttpResponse(status=202)
 253
 254 @api_method('DELETE')
 255 def container_delete(request, v_account, v_container):
 256     # Normal Response Codes: 204
 257     # Error Response Codes: serviceUnavailable (503),
 258     #                       conflict (409),
 259     #                       itemNotFound (404),
 260     #                       unauthorized (401),
 261     #                       badRequest (400)
 262
 263     try:
 264         backend.delete_container(request.user, v_container)
 265     except NameError:
 266         raise ItemNotFound('Container does not exist')
 267     except IndexError:
 268         raise Conflict('Container is not empty')
 269     return HttpResponse(status=204)
 270
 271 @api_method('GET', format_allowed=True)
 272 def object_list(request, v_account, v_container):
 273     # Normal Response Codes: 200, 204
 274     # Error Response Codes: serviceUnavailable (503),
 275     #                       itemNotFound (404),
 276     #                       unauthorized (401),
 277     #                       badRequest (400)
 278
 279     try:
 280         meta = backend.get_container_meta(request.user, v_container)
 281         meta['object_meta'] = backend.list_object_meta(request.user, v_container)
 282     except NameError:
 283         raise ItemNotFound('Container does not exist')
 284
 285     validate_modification_preconditions(request, meta)
 286
 287     response = HttpResponse()
 288     put_container_meta(response, meta)
 289
 290     path = request.GET.get('path')
 291     prefix = request.GET.get('prefix')
 292     delimiter = request.GET.get('delimiter')
 293
 294     # Path overrides prefix and delimiter.
 295     virtual = True
 296     if path:
 297         prefix = path
 298         delimiter = '/'
 299         virtual = False
 300
 301     # Naming policy.
 302     if prefix and delimiter:
 303         prefix = prefix + delimiter
 304     if not prefix:
 305         prefix = ''
 306     prefix = prefix.lstrip('/')
 307
 308     marker = request.GET.get('marker')
 309     limit = request.GET.get('limit')
 310     if limit:
 311         try:
 312             limit = int(limit)
 313             if limit <= 0:
 314                 raise ValueError
 315         except ValueError:
 316             limit = 10000
 317
 318     keys = request.GET.get('meta')
 319     if keys:
 320         keys = keys.split(',')
 321         keys = [format_meta_key('X-Object-Meta-' + x.strip()) for x in keys if x.strip() != '']
 322     else:
 323         keys = []
 324
 325     try:
 326         objects = backend.list_objects(request.user, v_container, prefix, delimiter, marker, limit, virtual, keys)
 327     except NameError:
 328         raise ItemNotFound('Container does not exist')
 329
 330     if request.serialization == 'text':
 331         if len(objects) == 0:
 332             # The cloudfiles python bindings expect 200 if json/xml.
 333             response.status_code = 204
 334             return response
 335         response.status_code = 200
 336         response.content = '\n'.join(objects) + '\n'
 337         return response
 338
 339     object_meta = []
 340     for x in objects:
 341         try:
 342             meta = backend.get_object_meta(request.user, v_container, x)
 343         except NameError:
 344             # Virtual objects/directories.
 345             if virtual and delimiter and x.endswith(delimiter):
 346                 object_meta.append({'subdir': x})
 347             continue
 348         object_meta.append(printable_meta_dict(meta))
 349     if request.serialization == 'xml':
 350         data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})
 351     elif request.serialization  == 'json':
 352         data = json.dumps(object_meta)
 353     response.status_code = 200
 354     response.content = data
 355     return response
 356
 357 @api_method('HEAD')
 358 def object_meta(request, v_account, v_container, v_object):
 359     # Normal Response Codes: 204
 360     # Error Response Codes: serviceUnavailable (503),
 361     #                       itemNotFound (404),
 362     #                       unauthorized (401),
 363     #                       badRequest (400)
 364
 365     try:
 366         meta = backend.get_object_meta(request.user, v_container, v_object)
 367     except NameError:
 368         raise ItemNotFound('Object does not exist')
 369
 370     response = HttpResponse(status=204)
 371     put_object_meta(response, meta)
 372     return response
 373
 374 @api_method('GET', format_allowed=True)
 375 def object_read(request, v_account, v_container, v_object):
 376     # Normal Response Codes: 200, 206
 377     # Error Response Codes: serviceUnavailable (503),
 378     #                       rangeNotSatisfiable (416),
 379     #                       preconditionFailed (412),
 380     #                       itemNotFound (404),
 381     #                       unauthorized (401),
 382     #                       badRequest (400),
 383     #                       notModified (304)
 384
 385     try:
 386         meta = backend.get_object_meta(request.user, v_container, v_object)
 387     except NameError:
 388         raise ItemNotFound('Object does not exist')
 389
 390     # Evaluate conditions.
 391     validate_modification_preconditions(request, meta)
 392     try:
 393         validate_matching_preconditions(request, meta)
 394     except NotModified:
 395         response = HttpResponse(status=304)
 396         response['ETag'] = meta['hash']
 397         return response
 398
 399     try:
 400         # TODO: Also check for IndexError.
 401         size, hashmap = backend.get_object_hashmap(request.user, v_container, v_object)
 402     except NameError:
 403         raise ItemNotFound('Object does not exist')
 404
 405     # Reply with the hashmap.
 406     if request.serialization != 'text':
 407         if request.serialization == 'xml':
 408             data = render_to_string('hashes.xml', {'object': v_object, 'bytes': size, 'hashes': hashmap})
 409         elif request.serialization  == 'json':
 410             data = json.dumps({'bytes': size, 'hashes': hashmap})
 411
 412         response = HttpResponse(data, status=200)
 413         put_object_meta(response, meta)
 414         response['Content-Length'] = len(data)
 415         return response
 416
 417     # Range handling.
 418     ranges = get_range(request, size)
 419     if ranges is None:
 420         ranges = [(0, size)]
 421         ret = 200
 422     else:
 423         check = [True for offset, length in ranges if
 424                     length <= 0 or length > size or
 425                     offset < 0 or offset >= size or
 426                     offset + length > size]
 427         if len(check) > 0:
 428             raise RangeNotSatisfiable('Requested range exceeds object limits')
 429         ret = 206
 430
 431     if ret == 206 and len(ranges) > 1:
 432         boundary = uuid.uuid4().hex
 433     else:
 434         boundary = ''
 435     wrapper = ObjectWrapper(request.user, v_container, v_object, ranges, size, hashmap, boundary)
 436     response = HttpResponse(wrapper, status=ret)
 437     put_object_meta(response, meta)
 438     if ret == 206:
 439         if len(ranges) == 1:
 440             offset, length = ranges[0]
 441             response['Content-Length'] = length # Update with the correct length.
 442             response['Content-Range'] = 'bytes %d-%d/%d' % (offset, offset + length - 1, size)
 443         else:
 444             del(response['Content-Length'])
 445             response['Content-Type'] = 'multipart/byteranges; boundary=%s' % (boundary,)
 446     return response
 447
 448 @api_method('PUT')
 449 def object_write(request, v_account, v_container, v_object):
 450     # Normal Response Codes: 201
 451     # Error Response Codes: serviceUnavailable (503),
 452     #                       unprocessableEntity (422),
 453     #                       lengthRequired (411),
 454     #                       itemNotFound (404),
 455     #                       unauthorized (401),
 456     #                       badRequest (400)
 457
 458     copy_from = request.META.get('HTTP_X_COPY_FROM')
 459     move_from = request.META.get('HTTP_X_MOVE_FROM')
 460     if copy_from or move_from:
 461         # TODO: Why is this required? Copy this ammount?
 462         content_length = get_content_length(request)
 463
 464         if move_from:
 465             copy_or_move_object(request, move_from, (v_container, v_object), move=True)
 466         else:
 467             copy_or_move_object(request, copy_from, (v_container, v_object), move=False)
 468         return HttpResponse(status=201)
 469
 470     meta = get_object_meta(request)
 471     content_length = -1
 472     if request.META.get('HTTP_TRANSFER_ENCODING') != 'chunked':
 473         content_length = get_content_length(request)
 474     # Should be BadRequest, but API says otherwise.
 475     if 'Content-Type' not in meta:
 476         raise LengthRequired('Missing Content-Type header')
 477
 478     md5 = hashlib.md5()
 479     if content_length == 0:
 480         try:
 481             backend.update_object_hashmap(request.user, v_container, v_object, 0, [])
 482         except NameError:
 483             raise ItemNotFound('Container does not exist')
 484     else:
 485         size = 0
 486         hashmap = []
 487         sock = raw_input_socket(request)
 488         for data in socket_read_iterator(sock, content_length, backend.block_size):
 489             # TODO: Raise 408 (Request Timeout) if this takes too long.
 490             # TODO: Raise 499 (Client Disconnect) if a length is defined and we stop before getting this much data.
 491             size += len(data)
 492             hashmap.append(backend.put_block(data))
 493             md5.update(data)
 494
 495     meta['hash'] = md5.hexdigest().lower()
 496     etag = request.META.get('HTTP_ETAG')
 497     if etag and parse_etags(etag)[0].lower() != meta['hash']:
 498         raise UnprocessableEntity('Object ETag does not match')
 499
 500     try:
 501         backend.update_object_hashmap(request.user, v_container, v_object, size, hashmap)
 502     except NameError:
 503         raise ItemNotFound('Container does not exist')
 504     try:
 505         backend.update_object_meta(request.user, v_container, v_object, meta)
 506     except NameError:
 507         raise ItemNotFound('Object does not exist')
 508
 509     response = HttpResponse(status=201)
 510     response['ETag'] = meta['hash']
 511     return response
 512
 513 @api_method('COPY')
 514 def object_copy(request, v_account, v_container, v_object):
 515     # Normal Response Codes: 201
 516     # Error Response Codes: serviceUnavailable (503),
 517     #                       itemNotFound (404),
 518     #                       unauthorized (401),
 519     #                       badRequest (400)
 520
 521     dest_path = request.META.get('HTTP_DESTINATION')
 522     if not dest_path:
 523         raise BadRequest('Missing Destination header')
 524     copy_or_move_object(request, (v_container, v_object), dest_path, move=False)
 525     return HttpResponse(status=201)
 526
 527 @api_method('MOVE')
 528 def object_move(request, v_account, v_container, v_object):
 529     # Normal Response Codes: 201
 530     # Error Response Codes: serviceUnavailable (503),
 531     #                       itemNotFound (404),
 532     #                       unauthorized (401),
 533     #                       badRequest (400)
 534
 535     dest_path = request.META.get('HTTP_DESTINATION')
 536     if not dest_path:
 537         raise BadRequest('Missing Destination header')
 538     copy_or_move_object(request, (v_container, v_object), dest_path, move=True)
 539     return HttpResponse(status=201)
 540
 541 @api_method('POST')
 542 def object_update(request, v_account, v_container, v_object):
 543     # Normal Response Codes: 202
 544     # Error Response Codes: serviceUnavailable (503),
 545     #                       itemNotFound (404),
 546     #                       unauthorized (401),
 547     #                       badRequest (400)
 548
 549     meta = get_object_meta(request)
 550     content_type = meta.get('Content-Type')
 551     if content_type:
 552         del(meta['Content-Type']) # Do not allow changing the Content-Type.
 553
 554     prev_meta = None
 555     if len(meta) != 0:
 556         try:
 557             prev_meta = backend.get_object_meta(request.user, v_container, v_object)
 558         except NameError:
 559             raise ItemNotFound('Object does not exist')
 560         # Keep previous values of 'Content-Type' and 'hash'.
 561         for k in ('Content-Type', 'hash'):
 562             if k in prev_meta:
 563                 meta[k] = prev_meta[k]
 564         try:
 565             backend.update_object_meta(request.user, v_container, v_object, meta, replace=True)
 566         except NameError:
 567             raise ItemNotFound('Object does not exist')
 568
 569     # Based on: http://code.google.com/p/gears/wiki/ContentRangePostProposal
 570     content_range = request.META.get('HTTP_CONTENT_RANGE')
 571     if not content_range:
 572         return HttpResponse(status=202)
 573     ranges = get_content_range(request)
 574     if not ranges:
 575         return HttpResponse(status=202)
 576
 577 #     # Need Content-Type and optional Transfer-Encoding.
 578 #     content_length = -1
 579 #     if request.META.get('HTTP_TRANSFER_ENCODING') != 'chunked':
 580 #         content_length = get_content_length(request)
 581 #     # Use BadRequest here, even if the API says otherwise for PUT.
 582 #     if not content_type:
 583 #         raise BadRequest('Missing Content-Type header')
 584 #
 585 #     if not prev_meta:
 586 #         try:
 587 #             prev_meta = backend.get_object_meta(request.user, v_container, v_object)
 588 #         except NameError:
 589 #             raise ItemNotFound('Object does not exist')
 590 #     size = prev_meta['bytes']
 591 #     offset, length, total = ranges
 592 #     if offset is None:
 593 #         offset = size
 594 #     if length is None:
 595 #         length = content_length # Nevermind the error.
 596 #     if total is not None and (total != size or offset >= size or (length > 0 and offset + length >= size)):
 597 #         raise RangeNotSatisfiable('Supplied range will change provided object limits')
 598 #
 599 #     sock = raw_input_socket(request)
 600 #     for data in socket_read_iterator(sock, length):
 601 #         # TODO: Raise 408 (Request Timeout) if this takes too long.
 602 #         # TODO: Raise 499 (Client Disconnect) if a length is defined and we stop before getting this much data.
 603 #         try:
 604 #             backend.update_object(request.user, v_container, v_object, data, offset)
 605 #         except NameError:
 606 #             raise ItemNotFound('Container does not exist')
 607 #         offset += len(data)
 608
 609     return HttpResponse(status=202)
 610
 611 @api_method('DELETE')
 612 def object_delete(request, v_account, v_container, v_object):
 613     # Normal Response Codes: 204
 614     # Error Response Codes: serviceUnavailable (503),
 615     #                       itemNotFound (404),
 616     #                       unauthorized (401),
 617     #                       badRequest (400)
 618
 619     try:
 620         backend.delete_object(request.user, v_container, v_object)
 621     except NameError:
 622         raise ItemNotFound('Object does not exist')
 623     return HttpResponse(status=204)
 624
 625 @api_method()
 626 def method_not_allowed(request):
 627     raise BadRequest('Method not allowed')