def tearDown(self):
for t in [
"django_rethink_test",
"history",
"django_rethink_test_reviewed",
"django_rethink_test_history_permissions",
"django_rethink_test_history_has_read_permission",
]:
r.table(t).delete().run(self.conn)
super(APITests, self).tearDown()
def delete(self):
if 'request' in self.context:
data = self.context['request'].data
if 'log' not in data:
if hasattr(self.Meta,
'log_required') and self.Meta.log_required:
raise serializers.ValidationError(
"'log' field is required when deleting an object")
log = None
else:
log = data['log']
elif 'log' in self.context:
log = self.context['log']
else:
log = None
result = r.table(self.Meta.table_name).get(
self.instance[self.Meta.pk_field]).delete(return_changes=True).run(
self.conn)
history = HistorySerializer(None,
data={
'object_type': self.Meta.table_name,
'object': {
self.Meta.pk_field:
self.instance[self.Meta.pk_field]
},
'username': self.get_username(),
'timestamp': timezone.now(),
'message': log,
})
history.is_valid(raise_exception=True)
history.save()
return result['deleted'] > 0
def create(self, validated_data):
if 'log' in validated_data:
log = validated_data.pop('log')
else:
log = None
if 'version' not in validated_data:
validated_data['version'] = 1
result = r.table(self.Meta.table_name).insert(validated_data,
return_changes=True).run(
self.conn)
history = HistorySerializer(None,
data={
'object_type':
self.Meta.table_name,
'object':
result['changes'][0]['new_val'].copy(),
'username':
self.get_username(),
'timestamp':
timezone.now(),
'message':
log,
})
history.is_valid(raise_exception=True)
history.save()
return result['changes'][0]['new_val']
def validate(self, data):
for group in self.Meta.unique_together:
value = [
data.get(
field,
self.instance.get(field, None)
if self.instance is not None else None) for field in group
]
for index in self.Meta.indices:
if isinstance(index, (tuple, list)) and isinstance(
index[1], tuple) and [str(i) for i in index[1]
] == [str(i) for i in group]:
query = r.table(self.Meta.table_name).get_all(
value, index=index[0])
break
else:
query = self.filter(dict([(field, value[i])
for i, field in enumerate(group)]),
reql=True)
if self.instance is not None:
query = query.filter(r.row[self.Meta.pk_field] !=
self.instance[self.Meta.pk_field])
query = query.count()
matched = query.run(self.conn)
if matched > 0:
raise serializers.ValidationError(
"combination of %r is not unique" % (group, ))
return data
def default_filter_queryset(self, queryset):
if '_include_object' in self.request.query_params:
return queryset.merge(
lambda review: {
"orig_object":
r.table(review['object_type']).get(review['object_id'])
})
else:
return queryset
def update(self, instance, validated_data):
queryset = r.table(self.Meta.table_name).get(instance['id'])
if self.partial:
queryset = queryset.update(validated_data, return_changes=True)
else:
queryset = queryset.replace(validated_data, return_changes=True)
result = queryset.run(self.conn)
if len(result['changes']) == 0:
return validated_data
else:
return result['changes'][0]['new_val']
def get_queryset(self):
if self.queryset is None:
if self.table_name:
return r.table(self.table_name)
else:
raise ImproperlyConfigured(
"%(cls)s is missing a QuerySet. Define "
"%(cls)s.model, %(cls)s.queryset, or override "
"%(cls)s.get_queryset()." %
{'cls': self.__class__.__name__})
return self.queryset
def rethinkdb_unlock(self, *args, **kwargs):
if 'name' in kwargs:
name = kwargs['name']
else:
name = args[0]
args = args[1:]
token = kwargs.get('token', self.request.root_id)
result = r.table("locks").get_all(_distributed_lock_id(name)). \
filter({"token": token}).delete().run(get_connection())
if result['deleted'] == 1:
logger.info("unlocked %s", name)
else:
logger.warning("unable to unlock %s, token was not %s", name, token)
if len(args) > 0:
return args[0]
def post(self, *args, **kwargs):
conn = self.get_connection()
update_data = self.get_update_data()
result = self.get_object_qs().update(
r.expr(update_data, nesting_depth=40)).run(conn)
if max(result.values()) == 0:
result = r.table(self.table_name).insert(
r.expr(self.get_insert_data(update_data),
nesting_depth=40)).run(conn)
self.post_update()
if self.request.META['CONTENT_TYPE'] == "application/json":
return HttpResponse(json.dumps({'success': True}),
content_type="application/json")
else:
return HttpResponseRedirect(self.get_success_url())
def rethinkdb_lock(self, name, token=None, timeout=300):
if token is None:
token = self.request.root_id
result = r.table("locks").insert({
"id": _distributed_lock_id(name),
"token": token,
"server": socket.gethostname(),
"timestamp": r.now(),
}).run(get_connection())
if result['inserted'] == 0:
self.retry(exc=Exception("failed to acquire lock %s" % name),
countdown=1,
max_retries=timeout)
else:
logger.info("locked %s with token %s", name, token)
return token
def update(self, instance, validated_data):
update = dict(validated_data)
if 'log' in update:
log = update.pop('log')
else:
log = None
if 'version' in validated_data:
old_version = validated_data['version']
else:
old_version = instance['version']
update['version'] = old_version + 1
filtered = r.table(self.Meta.table_name) \
.get_all(instance[self.Meta.pk_field]) \
.filter(r.row['version'] == old_version)
if self.partial:
result = filtered.update(update,
return_changes=True).run(self.conn)
else:
result = filtered.replace(update,
return_changes=True).run(self.conn)
if result['replaced'] + result['unchanged'] == 0:
raise SimultaneousObjectManipulationException(
"Simultaneous object manipulation error! %s %d" %
(instance[self.Meta.pk_field], instance['version']))
if len(result['changes']) == 0:
new_val = instance
else:
new_val = result['changes'][0]['new_val']
history = HistorySerializer(None,
data={
'object_type': self.Meta.table_name,
'object': new_val.copy(),
'username': self.get_username(),
'timestamp': timezone.now(),
'message': log,
})
history.is_valid(raise_exception=True)
history.save()
return new_val
def filter(cls, *args, **fields):
query = r.table(cls.Meta.table_name)
try:
reql = fields.pop('reql')
except KeyError:
reql = False
if len(args) == 0 and len(fields) == 1 and list(fields.keys(
))[0] in cls.Meta.indices and not cls.Meta.order_by:
index, value = list(fields.items())[0]
query = query.get_all(value, index=index)
else:
if args:
query = query.filter(*args)
if fields:
query = query.filter(fields)
if cls.Meta.order_by:
query = query.order_by(*cls.Meta.order_by)
if reql:
return query
else:
rs = query.run(get_connection())
if not isinstance(rs, list):
rs.reql_query = query
return rs
def delete(self):
result = r.table(self.Meta.table_name).get(
self.data[self.Meta.pk_field]).delete().run(self.conn)
return result['deleted'] > 0
def create(self, validated_data):
result = r.table(self.Meta.table_name).insert(validated_data,
return_changes=True).run(
self.conn)
return result['changes'][0]['new_val']
