def DeleteSubject(self, subject, token=None):
request = rdfvalue.DataStoreRequest(subject=[subject])
if token:
request.token = token
typ = rdfvalue.DataStoreCommand.Command.DELETE_SUBJECT
self._MakeAsyncRequest(request, typ)
def DeleteAttributes(self,
subject,
attributes,
start=None,
end=None,
token=None,
sync=None):
request = rdfvalue.DataStoreRequest(subject=[subject])
# Set timestamp.
start = start or 0
if end is None:
end = (2**63) - 1 # sys.maxint
request.timestamp = rdfvalue.TimestampSpec(
start=start, end=end, type=rdfvalue.TimestampSpec.Type.RANGED_TIME)
if token:
request.token = token
if sync:
request.sync = sync
for attr in attributes:
request.values.Append(predicate=attr)
typ = rdfvalue.DataStoreCommand.Command.DELETE_ATTRIBUTES
self._MakeRequestSyncOrAsync(request, typ, sync)
def MultiSet(self,
subject,
values,
timestamp=None,
token=None,
replace=True,
to_delete=None,
sync=True):
"""MultiSet."""
request = rdfvalue.DataStoreRequest(sync=sync)
token = token or data_store.default_token
if token:
request.token = token
request.subject.Append(subject)
now = time.time() * 1000000
if timestamp is None or timestamp == self.NEWEST_TIMESTAMP:
timestamp = now
to_delete = set(to_delete or [])
for predicate in to_delete:
if predicate not in values:
values[predicate] = [(None, 0)]
for k, seq in values.items():
for v in seq:
if isinstance(v, basestring):
element_timestamp = timestamp
else:
try:
v, element_timestamp = v
except (TypeError, ValueError):
element_timestamp = timestamp
option = rdfvalue.DataStoreValue.Option.DEFAULT
if replace or k in to_delete:
option = rdfvalue.DataStoreValue.Option.REPLACE
new_value = request.values.Append(
predicate=utils.SmartUnicode(k), option=option)
if element_timestamp is None:
element_timestamp = now
new_value.timestamp = self.TimestampSpecFromTimestamp(
element_timestamp)
if v is not None:
new_value.value.SetValue(v)
typ = rdfvalue.DataStoreCommand.Command.MULTI_SET
self._MakeRequestSyncOrAsync(request, typ, sync)
def DeleteAttributesRegex(self, subject, regexes, token=None):
"""Implement the DeleteAttributesRegex interface."""
request = rdfvalue.DataStoreRequest(subject=[subject])
if token:
request.token = token
if isinstance(regexes, basestring):
regexes = [regexes]
for regex in regexes:
request.values.Append(predicate=regex)
typ = rdfvalue.DataStoreCommand.Command.DELETE_ATTRIBUTES_REGEX
self._MakeSyncRequest(request, typ)
def UnlockSubject(self, subject, transid, token):
"""Unlocks subject using transaction id."""
request = rdfvalue.DataStoreRequest(subject=[subject])
if token:
request.token = token
blob = rdfvalue.DataBlob(string=transid)
value = rdfvalue.DataStoreValue(value=blob)
request.values.Append(value)
# We do not care about the server response.
typ = rdfvalue.DataStoreCommand.Command.UNLOCK_SUBJECT
self._MakeSyncRequest(request, typ)
return transid
def LockSubject(self, subject, lease_time, token):
"""Locks a specific subject."""
request = rdfvalue.DataStoreRequest(subject=[subject])
specific = rdfvalue.TimestampSpec.Type.SPECIFIC_TIME
request.timestamp = rdfvalue.TimestampSpec(start=lease_time, type=specific)
if token:
request.token = token
typ = rdfvalue.DataStoreCommand.Command.LOCK_SUBJECT
response = self._MakeSyncRequest(request, typ)
if not response.results:
return None
result = response.results[0]
if not result.values:
return None
return result.values[0].value.string
def _MakeRequest(self, subjects, predicates, timestamp=None, token=None,
limit=None):
if isinstance(predicates, basestring):
predicates = [predicates]
request = rdfvalue.DataStoreRequest(subject=subjects)
if limit:
request.limit = limit
token = token or data_store.default_token
if token:
request.token = token
if timestamp is not None:
request.timestamp = self.TimestampSpecFromTimestamp(timestamp)
for predicate in predicates:
request.values.Append(predicate=predicate)
return request
def ExtendSubjectLock(self, subject, transid, lease_time, token):
"""Extends lock of subject."""
request = rdfvalue.DataStoreRequest(subject=[subject])
specific = rdfvalue.TimestampSpec.Type.SPECIFIC_TIME
request.timestamp = rdfvalue.TimestampSpec(start=lease_time, type=specific)
if token:
request.token = token
blob = rdfvalue.DataBlob(string=transid)
value = rdfvalue.DataStoreValue(value=blob)
request.values.Append(value)
typ = rdfvalue.DataStoreCommand.Command.EXTEND_SUBJECT
response = self._MakeSyncRequest(request, typ)
if not response.results:
return None
result = response.results[0]
if not result.values:
return None
value = result.values[0].value.string
return transid if transid == value else None
def ResolveMulti(self, subject, attributes, token=None, timestamp=None):
"""ResolveMulti."""
request = rdfvalue.DataStoreRequest()
if timestamp is not None:
request.timestamp = self.TimestampSpecFromTimestamp(timestamp)
token = token or data_store.default_token
if token:
request.token = token
request.subject.Append(subject)
for attribute in attributes:
request.values.Append(predicate=attribute)
typ = rdfvalue.DataStoreCommand.Command.RESOLVE_MULTI
response = self._MakeSyncRequest(request, typ)
results = []
for result in response.results:
for (predicate, value, timestamp) in result.payload:
results.append((predicate, self._Decode(value), timestamp))
return results
