1 # Copyright 2011 GRNET S.A. All rights reserved.
3 # Redistribution and use in source and binary forms, with or
4 # without modification, are permitted provided that the following
7 # 1. Redistributions of source code must retain the above
8 # copyright notice, this list of conditions and the following
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.
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.
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.
38 from django.conf import settings
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
44 from pithos.api.faults import (Fault, NotModified, BadRequest, Unauthorized, ItemNotFound, Conflict,
45 LengthRequired, PreconditionFailed, RangeNotSatisfiable, UnprocessableEntity)
46 from pithos.api.util import (format_header_key, printable_header_dict, get_account_headers,
47 put_account_headers, get_container_headers, put_container_headers, get_object_headers, put_object_headers,
48 update_manifest_meta, update_sharing_meta, update_public_meta, validate_modification_preconditions,
49 validate_matching_preconditions, split_container_object_string, copy_or_move_object,
50 get_int_parameter, get_content_length, get_content_range, raw_input_socket,
51 socket_read_iterator, object_data_response, put_object_block, hashmap_hash, api_method)
52 from pithos.backends import backend
53 from pithos.backends.base import NotAllowedError
56 logger = logging.getLogger(__name__)
59 def top_demux(request):
60 if request.method == 'GET':
61 return authenticate(request)
63 return method_not_allowed(request)
65 def account_demux(request, v_account):
66 if request.method == 'HEAD':
67 return account_meta(request, v_account)
68 elif request.method == 'POST':
69 return account_update(request, v_account)
70 elif request.method == 'GET':
71 return container_list(request, v_account)
73 return method_not_allowed(request)
75 def container_demux(request, v_account, v_container):
76 if request.method == 'HEAD':
77 return container_meta(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 elif request.method == 'GET':
85 return object_list(request, v_account, v_container)
87 return method_not_allowed(request)
89 def object_demux(request, v_account, v_container, v_object):
90 if request.method == 'HEAD':
91 return object_meta(request, v_account, v_container, v_object)
92 elif request.method == 'GET':
93 return object_read(request, v_account, v_container, v_object)
94 elif request.method == 'PUT':
95 return object_write(request, v_account, v_container, v_object)
96 elif request.method == 'COPY':
97 return object_copy(request, v_account, v_container, v_object)
98 elif request.method == 'MOVE':
99 return object_move(request, v_account, v_container, v_object)
100 elif request.method == 'POST':
101 return object_update(request, v_account, v_container, v_object)
102 elif request.method == 'DELETE':
103 return object_delete(request, v_account, v_container, v_object)
105 return method_not_allowed(request)
108 def authenticate(request):
109 # Normal Response Codes: 204
110 # Error Response Codes: serviceUnavailable (503),
111 # unauthorized (401),
114 x_auth_user = request.META.get('HTTP_X_AUTH_USER')
115 x_auth_key = request.META.get('HTTP_X_AUTH_KEY')
116 if not x_auth_user or not x_auth_key:
117 raise BadRequest('Missing X-Auth-User or X-Auth-Key header')
118 response = HttpResponse(status=204)
119 inv_auth_tokens = dict((v, k) for k, v in settings.AUTH_TOKENS.items())
120 response['X-Auth-Token'] = inv_auth_tokens.get(x_auth_user, '0000')
121 response['X-Storage-Url'] = os.path.join(request.build_absolute_uri(),
126 def account_meta(request, v_account):
127 # Normal Response Codes: 204
128 # Error Response Codes: serviceUnavailable (503),
129 # unauthorized (401),
132 until = get_int_parameter(request.GET.get('until'))
134 meta = backend.get_account_meta(request.user, v_account, until)
135 groups = backend.get_account_groups(request.user, v_account)
136 except NotAllowedError:
137 raise Unauthorized('Access denied')
139 response = HttpResponse(status=204)
140 put_account_headers(response, meta, groups)
144 def account_update(request, v_account):
145 # Normal Response Codes: 202
146 # Error Response Codes: serviceUnavailable (503),
147 # unauthorized (401),
150 meta, groups = get_account_headers(request)
152 if 'update' in request.GET:
156 backend.update_account_groups(request.user, v_account, groups, replace)
157 except NotAllowedError:
158 raise Unauthorized('Access denied')
160 raise BadRequest('Invalid groups header')
162 backend.update_account_meta(request.user, v_account, meta, replace)
163 except NotAllowedError:
164 raise Unauthorized('Access denied')
165 return HttpResponse(status=202)
167 @api_method('GET', format_allowed=True)
168 def container_list(request, v_account):
169 # Normal Response Codes: 200, 204
170 # Error Response Codes: serviceUnavailable (503),
171 # itemNotFound (404),
172 # unauthorized (401),
175 until = get_int_parameter(request.GET.get('until'))
177 meta = backend.get_account_meta(request.user, v_account, until)
178 groups = backend.get_account_groups(request.user, v_account)
179 except NotAllowedError:
180 raise Unauthorized('Access denied')
182 validate_modification_preconditions(request, meta)
184 response = HttpResponse()
185 put_account_headers(response, meta, groups)
187 marker = request.GET.get('marker')
188 limit = request.GET.get('limit')
198 containers = backend.list_containers(request.user, v_account, marker, limit, until)
199 except NotAllowedError:
200 raise Unauthorized('Access denied')
204 if request.serialization == 'text':
205 if len(containers) == 0:
206 # The cloudfiles python bindings expect 200 if json/xml.
207 response.status_code = 204
209 response.status_code = 200
210 response.content = '\n'.join([x[0] for x in containers]) + '\n'
217 meta = backend.get_container_meta(request.user, v_account, x[0], until)
218 policy = backend.get_container_policy(request.user, v_account, x[0])
219 except NotAllowedError:
220 raise Unauthorized('Access denied')
224 for k, v in policy.iteritems():
225 meta['X-Container-Policy-' + k] = v
226 container_meta.append(printable_header_dict(meta))
227 if request.serialization == 'xml':
228 data = render_to_string('containers.xml', {'account': v_account, 'containers': container_meta})
229 elif request.serialization == 'json':
230 data = json.dumps(container_meta)
231 response.status_code = 200
232 response.content = data
236 def container_meta(request, v_account, v_container):
237 # Normal Response Codes: 204
238 # Error Response Codes: serviceUnavailable (503),
239 # itemNotFound (404),
240 # unauthorized (401),
243 until = get_int_parameter(request.GET.get('until'))
245 meta = backend.get_container_meta(request.user, v_account, v_container, until)
246 meta['object_meta'] = backend.list_object_meta(request.user, v_account, v_container, until)
247 policy = backend.get_container_policy(request.user, v_account, v_container)
248 except NotAllowedError:
249 raise Unauthorized('Access denied')
251 raise ItemNotFound('Container does not exist')
253 response = HttpResponse(status=204)
254 put_container_headers(response, meta, policy)
258 def container_create(request, v_account, v_container):
259 # Normal Response Codes: 201, 202
260 # Error Response Codes: serviceUnavailable (503),
261 # itemNotFound (404),
262 # unauthorized (401),
265 meta, policy = get_container_headers(request)
268 backend.put_container(request.user, v_account, v_container, policy)
270 except NotAllowedError:
271 raise Unauthorized('Access denied')
277 backend.update_container_meta(request.user, v_account, v_container, meta, replace=True)
278 except NotAllowedError:
279 raise Unauthorized('Access denied')
281 raise ItemNotFound('Container does not exist')
283 return HttpResponse(status=ret)
286 def container_update(request, v_account, v_container):
287 # Normal Response Codes: 202
288 # Error Response Codes: serviceUnavailable (503),
289 # itemNotFound (404),
290 # unauthorized (401),
293 meta, policy = get_container_headers(request)
295 if 'update' in request.GET:
299 backend.update_container_policy(request.user, v_account, v_container, policy, replace)
300 except NotAllowedError:
301 raise Unauthorized('Access denied')
303 raise ItemNotFound('Container does not exist')
305 raise BadRequest('Invalid policy header')
307 backend.update_container_meta(request.user, v_account, v_container, meta, replace)
308 except NotAllowedError:
309 raise Unauthorized('Access denied')
311 raise ItemNotFound('Container does not exist')
312 return HttpResponse(status=202)
314 @api_method('DELETE')
315 def container_delete(request, v_account, v_container):
316 # Normal Response Codes: 204
317 # Error Response Codes: serviceUnavailable (503),
319 # itemNotFound (404),
320 # unauthorized (401),
324 backend.delete_container(request.user, v_account, v_container)
325 except NotAllowedError:
326 raise Unauthorized('Access denied')
328 raise ItemNotFound('Container does not exist')
330 raise Conflict('Container is not empty')
331 return HttpResponse(status=204)
333 @api_method('GET', format_allowed=True)
334 def object_list(request, v_account, v_container):
335 # Normal Response Codes: 200, 204
336 # Error Response Codes: serviceUnavailable (503),
337 # itemNotFound (404),
338 # unauthorized (401),
341 until = get_int_parameter(request.GET.get('until'))
343 meta = backend.get_container_meta(request.user, v_account, v_container, until)
344 meta['object_meta'] = backend.list_object_meta(request.user, v_account, v_container, until)
345 policy = backend.get_container_policy(request.user, v_account, v_container)
346 except NotAllowedError:
347 raise Unauthorized('Access denied')
349 raise ItemNotFound('Container does not exist')
351 validate_modification_preconditions(request, meta)
353 response = HttpResponse()
354 put_container_headers(response, meta, policy)
356 path = request.GET.get('path')
357 prefix = request.GET.get('prefix')
358 delimiter = request.GET.get('delimiter')
360 # Path overrides prefix and delimiter.
368 if prefix and delimiter:
369 prefix = prefix + delimiter
372 prefix = prefix.lstrip('/')
374 marker = request.GET.get('marker')
375 limit = request.GET.get('limit')
384 keys = request.GET.get('meta')
386 keys = keys.split(',')
387 keys = [format_header_key('X-Object-Meta-' + x.strip()) for x in keys if x.strip() != '']
392 objects = backend.list_objects(request.user, v_account, v_container, prefix, delimiter, marker, limit, virtual, keys, until)
393 except NotAllowedError:
394 raise Unauthorized('Access denied')
396 raise ItemNotFound('Container does not exist')
398 if request.serialization == 'text':
399 if len(objects) == 0:
400 # The cloudfiles python bindings expect 200 if json/xml.
401 response.status_code = 204
403 response.status_code = 200
404 response.content = '\n'.join([x[0] for x in objects]) + '\n'
410 # Virtual objects/directories.
411 object_meta.append({'subdir': x[0]})
414 meta = backend.get_object_meta(request.user, v_account, v_container, x[0], x[1])
416 permissions = backend.get_object_permissions(request.user, v_account, v_container, x[0])
417 public = backend.get_object_public(request.user, v_account, v_container, x[0])
421 except NotAllowedError:
422 raise Unauthorized('Access denied')
426 update_sharing_meta(permissions, v_account, v_container, x[0], meta)
427 update_public_meta(public, meta)
428 object_meta.append(printable_header_dict(meta))
429 if request.serialization == 'xml':
430 data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})
431 elif request.serialization == 'json':
432 data = json.dumps(object_meta)
433 response.status_code = 200
434 response.content = data
438 def object_meta(request, v_account, v_container, v_object):
439 # Normal Response Codes: 204
440 # Error Response Codes: serviceUnavailable (503),
441 # itemNotFound (404),
442 # unauthorized (401),
445 version = request.GET.get('version')
447 meta = backend.get_object_meta(request.user, v_account, v_container, v_object, version)
449 permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)
450 public = backend.get_object_public(request.user, v_account, v_container, v_object)
454 except NotAllowedError:
455 raise Unauthorized('Access denied')
457 raise ItemNotFound('Object does not exist')
459 raise ItemNotFound('Version does not exist')
461 update_manifest_meta(request, v_account, meta)
462 update_sharing_meta(permissions, v_account, v_container, v_object, meta)
463 update_public_meta(public, meta)
465 response = HttpResponse(status=200)
466 put_object_headers(response, meta)
469 @api_method('GET', format_allowed=True)
470 def object_read(request, v_account, v_container, v_object):
471 # Normal Response Codes: 200, 206
472 # Error Response Codes: serviceUnavailable (503),
473 # rangeNotSatisfiable (416),
474 # preconditionFailed (412),
475 # itemNotFound (404),
476 # unauthorized (401),
480 version = request.GET.get('version')
482 # Reply with the version list. Do this first, as the object may be deleted.
483 if version == 'list':
484 if request.serialization == 'text':
485 raise BadRequest('No format specified for version list.')
488 v = backend.list_versions(request.user, v_account, v_container, v_object)
489 except NotAllowedError:
490 raise Unauthorized('Access denied')
492 if request.serialization == 'xml':
493 d['object'] = v_object
494 data = render_to_string('versions.xml', d)
495 elif request.serialization == 'json':
498 response = HttpResponse(data, status=200)
499 response['Content-Length'] = len(data)
503 meta = backend.get_object_meta(request.user, v_account, v_container, v_object, version)
505 permissions = backend.get_object_permissions(request.user, v_account, v_container, v_object)
506 public = backend.get_object_public(request.user, v_account, v_container, v_object)
510 except NotAllowedError:
511 raise Unauthorized('Access denied')
513 raise ItemNotFound('Object does not exist')
515 raise ItemNotFound('Version does not exist')
517 update_manifest_meta(request, v_account, meta)
518 update_sharing_meta(permissions, v_account, v_container, v_object, meta)
519 update_public_meta(public, meta)
521 # Evaluate conditions.
522 validate_modification_preconditions(request, meta)
524 validate_matching_preconditions(request, meta)
526 response = HttpResponse(status=304)
527 response['ETag'] = meta['hash']
532 if 'X-Object-Manifest' in meta:
534 src_container, src_name = split_container_object_string('/' + meta['X-Object-Manifest'])
535 objects = backend.list_objects(request.user, v_account, src_container, prefix=src_name, virtual=False)
536 except NotAllowedError:
537 raise Unauthorized('Access denied')
539 raise BadRequest('Invalid X-Object-Manifest header')
541 raise ItemNotFound('Container does not exist')
545 s, h = backend.get_object_hashmap(request.user, v_account, src_container, x[0], x[1])
548 except NotAllowedError:
549 raise Unauthorized('Access denied')
551 raise ItemNotFound('Object does not exist')
553 raise ItemNotFound('Version does not exist')
556 s, h = backend.get_object_hashmap(request.user, v_account, v_container, v_object, version)
559 except NotAllowedError:
560 raise Unauthorized('Access denied')
562 raise ItemNotFound('Object does not exist')
564 raise ItemNotFound('Version does not exist')
566 # Reply with the hashmap.
567 if request.serialization != 'text':
569 hashmap = sum(hashmaps, [])
570 d = {'block_size': backend.block_size, 'block_hash': backend.hash_algorithm, 'bytes': size, 'hashes': hashmap}
571 if request.serialization == 'xml':
572 d['object'] = v_object
573 data = render_to_string('hashes.xml', d)
574 elif request.serialization == 'json':
577 response = HttpResponse(data, status=200)
578 put_object_headers(response, meta)
579 response['Content-Length'] = len(data)
582 return object_data_response(request, sizes, hashmaps, meta)
584 @api_method('PUT', format_allowed=True)
585 def object_write(request, v_account, v_container, v_object):
586 # Normal Response Codes: 201
587 # Error Response Codes: serviceUnavailable (503),
588 # unprocessableEntity (422),
589 # lengthRequired (411),
591 # itemNotFound (404),
592 # unauthorized (401),
595 if not request.GET.get('format'):
596 request.serialization = 'text'
598 copy_from = request.META.get('HTTP_X_COPY_FROM')
599 move_from = request.META.get('HTTP_X_MOVE_FROM')
600 if copy_from or move_from:
601 content_length = get_content_length(request) # Required by the API.
605 src_container, src_name = split_container_object_string(move_from)
607 raise BadRequest('Invalid X-Move-From header')
608 copy_or_move_object(request, v_account, src_container, src_name, v_container, v_object, move=True)
611 src_container, src_name = split_container_object_string(copy_from)
613 raise BadRequest('Invalid X-Copy-From header')
614 copy_or_move_object(request, v_account, src_container, src_name, v_container, v_object, move=False)
615 return HttpResponse(status=201)
617 meta, permissions, public = get_object_headers(request)
619 if request.META.get('HTTP_TRANSFER_ENCODING') != 'chunked':
620 content_length = get_content_length(request)
621 # Should be BadRequest, but API says otherwise.
622 if 'Content-Type' not in meta:
623 raise LengthRequired('Missing Content-Type header')
625 if request.serialization == 'json':
627 sock = raw_input_socket(request)
628 for block in socket_read_iterator(sock, content_length, backend.block_size):
629 data = '%s%s' % (data, block)
631 if not hasattr(d, '__getitem__'):
632 raise BadRequest('Invalid data formating')
634 hashmap = d['hashes']
637 raise BadRequest('Invalid data formatting')
638 meta.update({'hash': hashmap_hash(hashmap)}) # Update ETag.
639 elif request.serialization == 'xml':
640 #TODO support for xml
641 raise BadRequest('Format xml is not supported')
646 sock = raw_input_socket(request)
647 for data in socket_read_iterator(sock, content_length, backend.block_size):
648 # TODO: Raise 408 (Request Timeout) if this takes too long.
649 # TODO: Raise 499 (Client Disconnect) if a length is defined and we stop before getting this much data.
651 hashmap.append(backend.put_block(data))
654 meta['hash'] = md5.hexdigest().lower()
655 etag = request.META.get('HTTP_ETAG')
656 if etag and parse_etags(etag)[0].lower() != meta['hash']:
657 raise UnprocessableEntity('Object ETag does not match')
660 backend.update_object_hashmap(request.user, v_account, v_container, v_object, size, hashmap, meta, True, permissions)
661 except NotAllowedError:
662 raise Unauthorized('Access denied')
663 except IndexError, e:
664 raise Conflict(json.dumps(e.data))
666 raise ItemNotFound('Container does not exist')
668 raise BadRequest('Invalid sharing header')
669 except AttributeError, e:
670 raise Conflict(json.dumps(e.data))
671 if public is not None:
673 backend.update_object_public(request.user, v_account, v_container, v_object, public)
674 except NotAllowedError:
675 raise Unauthorized('Access denied')
677 raise ItemNotFound('Object does not exist')
679 response = HttpResponse(status=201)
680 response['ETag'] = meta['hash']
684 def object_copy(request, v_account, v_container, v_object):
685 # Normal Response Codes: 201
686 # Error Response Codes: serviceUnavailable (503),
687 # itemNotFound (404),
688 # unauthorized (401),
691 dest_path = request.META.get('HTTP_DESTINATION')
693 raise BadRequest('Missing Destination header')
695 dest_container, dest_name = split_container_object_string(dest_path)
697 raise BadRequest('Invalid Destination header')
698 copy_or_move_object(request, v_account, v_container, v_object, dest_container, dest_name, move=False)
699 return HttpResponse(status=201)
702 def object_move(request, v_account, v_container, v_object):
703 # Normal Response Codes: 201
704 # Error Response Codes: serviceUnavailable (503),
705 # itemNotFound (404),
706 # unauthorized (401),
709 dest_path = request.META.get('HTTP_DESTINATION')
711 raise BadRequest('Missing Destination header')
713 dest_container, dest_name = split_container_object_string(dest_path)
715 raise BadRequest('Invalid Destination header')
716 copy_or_move_object(request, v_account, v_container, v_object, dest_container, dest_name, move=True)
717 return HttpResponse(status=201)
720 def object_update(request, v_account, v_container, v_object):
721 # Normal Response Codes: 202, 204
722 # Error Response Codes: serviceUnavailable (503),
724 # itemNotFound (404),
725 # unauthorized (401),
728 meta, permissions, public = get_object_headers(request)
729 content_type = meta.get('Content-Type')
731 del(meta['Content-Type']) # Do not allow changing the Content-Type.
734 prev_meta = backend.get_object_meta(request.user, v_account, v_container, v_object)
735 except NotAllowedError:
736 raise Unauthorized('Access denied')
738 raise ItemNotFound('Object does not exist')
739 # If replacing, keep previous values of 'Content-Type' and 'hash'.
741 if 'update' in request.GET:
744 for k in ('Content-Type', 'hash'):
746 meta[k] = prev_meta[k]
748 # A Content-Type or X-Source-Object header indicates data updates.
749 src_object = request.META.get('HTTP_X_SOURCE_OBJECT')
750 if (not content_type or content_type != 'application/octet-stream') and not src_object:
751 # Do permissions first, as it may fail easier.
752 if permissions is not None:
754 backend.update_object_permissions(request.user, v_account, v_container, v_object, permissions)
755 except NotAllowedError:
756 raise Unauthorized('Access denied')
758 raise ItemNotFound('Object does not exist')
760 raise BadRequest('Invalid sharing header')
761 except AttributeError, e:
762 raise Conflict(json.dumps(e.data))
763 if public is not None:
765 backend.update_object_public(request.user, v_account, v_container, v_object, public)
766 except NotAllowedError:
767 raise Unauthorized('Access denied')
769 raise ItemNotFound('Object does not exist')
771 backend.update_object_meta(request.user, v_account, v_container, v_object, meta, replace)
772 except NotAllowedError:
773 raise Unauthorized('Access denied')
775 raise ItemNotFound('Object does not exist')
776 return HttpResponse(status=202)
778 # Single range update. Range must be in Content-Range.
779 # Based on: http://code.google.com/p/gears/wiki/ContentRangePostProposal
780 # (with the addition that '*' is allowed for the range - will append).
781 content_range = request.META.get('HTTP_CONTENT_RANGE')
782 if not content_range:
783 raise BadRequest('Missing Content-Range header')
784 ranges = get_content_range(request)
786 raise RangeNotSatisfiable('Invalid Content-Range header')
789 size, hashmap = backend.get_object_hashmap(request.user, v_account, v_container, v_object)
790 except NotAllowedError:
791 raise Unauthorized('Access denied')
793 raise ItemNotFound('Object does not exist')
795 offset, length, total = ranges
799 raise RangeNotSatisfiable('Supplied offset is beyond object limits')
801 src_container, src_name = split_container_object_string(src_object)
802 src_version = request.META.get('HTTP_X_SOURCE_VERSION')
804 src_size, src_hashmap = backend.get_object_hashmap(request.user, v_account, src_container, src_name, src_version)
805 except NotAllowedError:
806 raise Unauthorized('Access denied')
808 raise ItemNotFound('Source object does not exist')
812 elif length > src_size:
813 raise BadRequest('Object length is smaller than range length')
815 # Require either a Content-Length, or 'chunked' Transfer-Encoding.
817 if request.META.get('HTTP_TRANSFER_ENCODING') != 'chunked':
818 content_length = get_content_length(request)
821 length = content_length
823 if content_length == -1:
824 # TODO: Get up to length bytes in chunks.
825 length = content_length
826 elif length != content_length:
827 raise BadRequest('Content length does not match range length')
828 if total is not None and (total != size or offset >= size or (length > 0 and offset + length >= size)):
829 raise RangeNotSatisfiable('Supplied range will change provided object limits')
831 dest_bytes = request.META.get('HTTP_X_OBJECT_BYTES')
832 if dest_bytes is not None:
833 dest_bytes = get_int_parameter(dest_bytes)
834 if dest_bytes is None:
835 raise BadRequest('Invalid X-Object-Bytes header')
838 if offset % backend.block_size == 0:
839 # Update the hashes only.
842 bi = int(offset / backend.block_size)
843 bl = min(length, backend.block_size)
844 if bi < len(hashmap):
845 if bl == backend.block_size:
846 hashmap[bi] = src_hashmap[sbi]
848 data = backend.get_block(src_hashmap[sbi])
849 hashmap[bi] = backend.update_block(hashmap[bi], data[:bl], 0)
851 hashmap.append(src_hashmap[sbi])
859 data += backend.get_block(src_hashmap[sbi])
860 if length < backend.block_size:
862 bytes = put_object_block(hashmap, data, offset)
868 sock = raw_input_socket(request)
870 for d in socket_read_iterator(sock, length, backend.block_size):
871 # TODO: Raise 408 (Request Timeout) if this takes too long.
872 # TODO: Raise 499 (Client Disconnect) if a length is defined and we stop before getting this much data.
874 bytes = put_object_block(hashmap, data, offset)
878 put_object_block(hashmap, data, offset)
882 if dest_bytes is not None and dest_bytes < size:
884 hashmap = hashmap[:(int((size - 1) / backend.block_size) + 1)]
885 meta.update({'hash': hashmap_hash(hashmap)}) # Update ETag.
887 backend.update_object_hashmap(request.user, v_account, v_container, v_object, size, hashmap, meta, replace, permissions)
888 except NotAllowedError:
889 raise Unauthorized('Access denied')
891 raise ItemNotFound('Container does not exist')
893 raise BadRequest('Invalid sharing header')
894 except AttributeError, e:
895 raise Conflict(json.dumps(e.data))
896 if public is not None:
898 backend.update_object_public(request.user, v_account, v_container, v_object, public)
899 except NotAllowedError:
900 raise Unauthorized('Access denied')
902 raise ItemNotFound('Object does not exist')
904 response = HttpResponse(status=204)
905 response['ETag'] = meta['hash']
908 @api_method('DELETE')
909 def object_delete(request, v_account, v_container, v_object):
910 # Normal Response Codes: 204
911 # Error Response Codes: serviceUnavailable (503),
912 # itemNotFound (404),
913 # unauthorized (401),
917 backend.delete_object(request.user, v_account, v_container, v_object)
918 except NotAllowedError:
919 raise Unauthorized('Access denied')
921 raise ItemNotFound('Object does not exist')
922 return HttpResponse(status=204)
925 def method_not_allowed(request):
926 raise BadRequest('Method not allowed')