update_manifest_meta, update_sharing_meta, update_public_meta, validate_modification_preconditions,
validate_matching_preconditions, split_container_object_string, copy_or_move_object,
get_int_parameter, get_content_length, get_content_range, socket_read_iterator,
- object_data_response, put_object_block, hashmap_hash, api_method)
+ object_data_response, put_object_block, hashmap_hash, api_method, json_encode_decimal)
from pithos.backends import connect_backend
from pithos.backends.base import NotAllowedError
validate_modification_preconditions(request, meta)
response = HttpResponse(status=204)
- put_account_headers(response, meta, groups)
+ put_account_headers(response, request.quota, meta, groups)
return response
@api_method('POST')
validate_modification_preconditions(request, meta)
response = HttpResponse()
- put_account_headers(response, meta, groups)
+ put_account_headers(response, request.quota, meta, groups)
marker = request.GET.get('marker')
limit = get_int_parameter(request.GET.get('limit'))
# badRequest (400)
meta, policy = get_container_headers(request)
+ try:
+ if policy and int(policy.get('quota', 0)) > request.quota:
+ policy['quota'] = request.quota
+ except:
+ raise BadRequest('Invalid quota header')
try:
- request.backend.put_container(request.user, v_account, v_container,
- policy)
+ request.backend.put_container(request.user, v_account, v_container, policy)
ret = 201
except NotAllowedError:
raise Unauthorized('Access denied')
replace = False
if policy:
try:
+ if int(policy.get('quota', 0)) > request.quota:
+ policy['quota'] = request.quota
+ except:
+ raise BadRequest('Invalid quota header')
+ try:
request.backend.update_container_policy(request.user, v_account,
v_container, policy, replace)
except NotAllowedError:
if request.serialization == 'xml':
data = render_to_string('objects.xml', {'container': v_container, 'objects': object_meta})
elif request.serialization == 'json':
- data = json.dumps(object_meta)
+ data = json.dumps(object_meta, default=json_encode_decimal)
response.status_code = 200
response.content = data
return response
d['object'] = v_object
data = render_to_string('versions.xml', d)
elif request.serialization == 'json':
- data = json.dumps(d)
+ data = json.dumps(d, default=json_encode_decimal)
response = HttpResponse(data, status=200)
response['Content-Length'] = len(data)
# or implied, of GRNET S.A.
from time import time
-from sqlalchemy import Table, Integer, BigInteger, Float, Column, String, MetaData, ForeignKey
+from sqlalchemy import Table, Integer, BigInteger, DECIMAL, Column, String, MetaData, ForeignKey
from sqlalchemy.schema import Index, Sequence
from sqlalchemy.sql import func, and_, or_, null, select, bindparam
from sqlalchemy.ext.compiler import compiles
from dbworker import DBWorker
-ROOTNODE = 0
+ROOTNODE = 1
( SERIAL, NODE, HASH, SIZE, SOURCE, MTIME, MUSER, CLUSTER ) = range(8)
columns.append(Column('path', String(2048), default='', nullable=False))
self.nodes = Table('nodes', metadata, *columns)
# place an index on path
- Index('idx_nodes_path', self.nodes.c.path, unique=True)
+ Index('idx_nodes_path', self.nodes.c.path)
#create statistics table
columns=[]
primary_key=True))
columns.append(Column('population', Integer, nullable=False, default=0))
columns.append(Column('size', BigInteger, nullable=False, default=0))
- columns.append(Column('mtime', Float))
+ columns.append(Column('mtime', DECIMAL))
columns.append(Column('cluster', Integer, nullable=False, default=0,
primary_key=True))
self.statistics = Table('statistics', metadata, *columns)
columns.append(Column('hash', String(255)))
columns.append(Column('size', BigInteger, nullable=False, default=0))
columns.append(Column('source', Integer))
- columns.append(Column('mtime', Float))
+ columns.append(Column('mtime', DECIMAL))
columns.append(Column('muser', String(255), nullable=False, default=''))
columns.append(Column('cluster', Integer, nullable=False, default=0))
self.versions = Table('versions', metadata, *columns)
c1 = select([self.nodes.c.node],
self.nodes.c.parent == parent)
where_clause = and_(self.versions.c.node.in_(c1),
- self.versions.c.cluster == cluster,
- self.versions.c.mtime <= before)
+ self.versions.c.cluster == cluster)
s = select([func.count(self.versions.c.serial),
func.sum(self.versions.c.size)])
s = s.where(where_clause)
+ if before != inf:
+ s = s.where(self.versions.c.mtime <= before)
r = self.conn.execute(s)
row = r.fetchone()
r.close()
s = select([func.count(self.versions.c.serial),
func.sum(self.versions.c.size)])
where_clause = and_(self.versions.c.node == node,
- self.versions.c.cluster == cluster,
- self.versions.c.mtime <= before)
+ self.versions.c.cluster == cluster)
s = s.where(where_clause)
+ if before != inf:
+ s = s.where(self.versions.c.mtime <= before)
r = self.conn.execute(s)
row = r.fetchone()
nr, size = row[0], row[1]
self.versions.c.mtime,
self.versions.c.muser,
self.versions.c.cluster])
+ filtered = select([func.max(self.versions.c.serial)],
+ self.versions.c.node == node)
+ if before != inf:
+ filtered = filtered.where(self.versions.c.mtime < before)
s = s.where(and_(self.versions.c.cluster != except_cluster,
- self.versions.c.serial == select(
- [func.max(self.versions.c.serial)],
- and_(self.versions.c.node == node,
- self.versions.c.mtime < before))))
+ self.versions.c.serial == filtered))
r = self.conn.execute(s)
props = r.fetchone()
r.close()
s = select([func.count(v.c.serial),
func.sum(v.c.size),
func.max(v.c.mtime)])
- c1 = select([func.max(self.versions.c.serial)],
- and_(self.versions.c.node == v.c.node,
- self.versions.c.mtime < before))
+ c1 = select([func.max(self.versions.c.serial)])
+ if before != inf:
+ c1 = c1.where(self.versions.c.mtime < before)
c2 = select([self.nodes.c.node], self.nodes.c.parent == node)
- s = s.where(and_(v.c.serial == c1,
+ s = s.where(and_(v.c.serial == c1.where(self.versions.c.node == v.c.node),
v.c.cluster != except_cluster,
v.c.node.in_(c2)))
rp = self.conn.execute(s)
func.sum(v.c.size),
func.max(v.c.mtime)])
c1 = select([func.max(self.versions.c.serial)],
- and_(self.versions.c.node == v.c.node,
- self.versions.c.mtime < before))
+ self.versions.c.node == v.c.node)
+ if before != inf:
+ c1 = c1.where(self.versions.c.mtime < before)
c2 = select([self.nodes.c.node], self.nodes.c.path.like(path + '%'))
s = s.where(and_(v.c.serial == c1,
v.c.cluster != except_cluster,
s = select([v.c.serial, v.c.node, v.c.hash, v.c.size,
v.c.source, v.c.mtime, v.c.muser, v.c.cluster])
c = select([func.max(self.versions.c.serial)],
- and_(self.versions.c.node == node,
- self.versions.c.mtime < before))
+ self.versions.c.node == node)
+ if before != inf:
+ c = c.where(self.versions.c.mtime < before)
s = s.where(and_(v.c.serial == c,
v.c.cluster == cluster))
r = self.conn.execute(s)
v = self.versions.alias('v')
n = self.nodes.alias('n')
s = select([a.c.key]).distinct()
- s = s.where(v.c.serial == select([func.max(self.versions.c.serial)],
- and_(self.versions.c.node == v.c.node,
- self.versions.c.mtime < before)))
+ filtered = select([func.max(self.versions.c.serial)])
+ if before != inf:
+ filtered = filtered.where(self.versions.c.mtime < before)
+ s = s.where(v.c.serial == filtered.where(self.versions.c.node == v.c.node))
s = s.where(v.c.cluster != except_cluster)
s = s.where(v.c.node.in_(select([self.nodes.c.node],
self.nodes.c.parent == parent)))
v = self.versions.alias('v')
n = self.nodes.alias('n')
s = select([n.c.path, v.c.serial]).distinct()
- s = s.where(v.c.serial == select([func.max(self.versions.c.serial)],
- and_(self.versions.c.node == v.c.node,
- self.versions.c.mtime < before)))
+ filtered = select([func.max(self.versions.c.serial)])
+ if before != inf:
+ filtered = filtered.where(self.versions.c.mtime < before)
+ s = s.where(v.c.serial == filtered.where(self.versions.c.node == v.c.node))
s = s.where(v.c.cluster != except_cluster)
s = s.where(v.c.node.in_(select([self.nodes.c.node],
self.nodes.c.parent == parent)))