def testArray(self):
sample = rdf_protodict.RDFValueArray()
# Add a string.
sample.Append("hello")
self.assertEqual(len(sample), 1)
self.assertEqual(sample[0], "hello")
# Add another RDFValue
sample.Append(rdfvalue.RDFString("hello"))
self.assertIsInstance(sample[1], rdfvalue.RDFString)
# Test iterator.
sample_list = list(sample)
self.assertIsInstance(sample_list, list)
self.assertIsInstance(sample_list[0], str)
self.assertIsInstance(sample_list[1], rdfvalue.RDFString)
# Test initialization from a list of variable types.
test_list = [
1,
2, # Integers.
None, # None.
rdfvalue.RDFDatetime.Now(), # An RDFValue instance.
[1, 2], # A nested list.
u"升级程序", # Unicode.
]
sample = rdf_protodict.RDFValueArray(test_list)
for x, y in zip(sample, test_list):
self.assertEqual(x.__class__, y.__class__)
self.assertEqual(x, y)
def Layout(self, request, response):
"""Render the protobuf as a table."""
# Remove these from the request in case we need to pass it to another
# renderer.
start = int(request.REQ.pop("start", 0))
length = int(request.REQ.pop("length", 10))
# We can get called again to render from an existing cache.
cache = request.REQ.pop("cache", None)
if cache:
self.cache = aff4.FACTORY.Open(cache, token=request.token)
self.proxy = rdf_protodict.RDFValueArray(self.cache.Read(1000000))
else:
# We need to create a cache if this is too long.
if len(self.proxy) > length:
# Make a cache
with aff4.FACTORY.Create(
None, aff4_standard.TempMemoryFile,
token=request.token) as self.cache:
data = rdf_protodict.RDFValueArray()
data.Extend(self.proxy)
self.cache.Write(data.SerializeToString())
self.data = []
self.next_start = 0
for i, element in enumerate(self.proxy):
if i < start:
continue
elif len(self.data) > length:
self.next_start = i
self.length = 100
break
renderer = FindRendererForObject(element)
if renderer:
try:
self.data.append(renderer.RawHTML(request))
except Exception as e: # pylint: disable=broad-except
logging.error("Unable to render %s with %s: %s",
type(element), renderer, e)
response = super(RDFValueArrayRenderer, self).Layout(request, response)
if self.next_start:
response = self.CallJavascript(
response,
"RDFValueArrayRenderer.Layout",
next_start=self.next_start,
cache_urn=self.cache.urn,
array_length=self.length)
return response
def Run(self, args):
self.context = args.context
self.filter_query = args.query
with vfs.VFSOpen(args.pathspec, progress_callback=self.Progress) as fd:
data = fd.Read(self.MAX_PLIST_SIZE)
plist = binplist.readPlist(cStringIO.StringIO(data))
# Create the query parser
parser = plist_lib.PlistFilterParser(self.filter_query).Parse()
filter_imp = plist_lib.PlistFilterImplementation
matcher = parser.Compile(filter_imp)
if self.context:
# Obtain the values for the context using the value expander
value_expander = filter_imp.FILTERS["ValueExpander"]
iterator = value_expander().Expand(plist, self.context)
else:
# If we didn't get a context, the context is the whole plist
iterator = [plist]
reply = protodict.RDFValueArray()
for item in iterator:
# As we're setting the context manually, we need to account for types
if isinstance(item, types.ListType):
for sub_item in item:
partial_plist = plist_lib.PlistValueToPlainValue(
sub_item)
if matcher.Matches(partial_plist):
reply.Append(sub_item)
else:
partial_plist = plist_lib.PlistValueToPlainValue(item)
if matcher.Matches(partial_plist):
reply.Append(partial_plist)
self.SendReply(reply)
def testAgePreserved(self):
data = rdf_protodict.RDFValueArray([1, 2, 3])
now = rdfvalue.RDFDatetime().Now()
original_age = data.age.Now()
self.assertTrue((now - data.age) < rdfvalue.Duration("5s"))
embedded = rdf_protodict.EmbeddedRDFValue(payload=data)
self.assertEqual(embedded.payload.age, original_age)
new_log = rdf_protodict.EmbeddedRDFValue(embedded).payload
self.assertEqual(
new_log.age, original_age, "Age not preserved: %s != %s" %
(new_log.age.AsMicroSecondsFromEpoch(),
original_age.AsMicroSecondsFromEpoch()))
def GenerateSample(self, number=0): return rdf_protodict.EmbeddedRDFValue(rdf_protodict.RDFValueArray([number]))
