def testCorrectlyExportsFourValuesOfTwoDifferentTypes(self): with self.pool: self.collection.Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFString("foo"), source=self.client_id), mutation_pool=self.pool) self.collection.Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFInteger(42), source=self.client_id), mutation_pool=self.pool) self.collection.Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFString("bar"), source=self.client_id), mutation_pool=self.pool) self.collection.Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFInteger(43), source=self.client_id), mutation_pool=self.pool) chunks = self.ProcessPlugin() self.assertListEqual(chunks, [ "Start: aff4:/foo/bar", "Values of type: RDFInteger", "First pass: 42 (source=%s)" % self.client_id, "First pass: 43 (source=%s)" % self.client_id, "Second pass: 42 (source=%s)" % self.client_id, "Second pass: 43 (source=%s)" % self.client_id, "Values of type: RDFString", "First pass: foo (source=%s)" % self.client_id, "First pass: bar (source=%s)" % self.client_id, "Second pass: foo (source=%s)" % self.client_id, "Second pass: bar (source=%s)" % self.client_id, "Finish: aff4:/foo/bar" ]) # pyformat: disable
def testResultsViewGetsAutoRefreshed(self): client_id = self.SetupClient(0) h = self.CreateSampleHunt() with data_store.DB.GetMutationPool() as pool: h.ResultCollection().Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFString("foo-result"), source=client_id), mutation_pool=pool) self.Open("/") # Ensure auto-refresh updates happen every second. self.GetJavaScriptValue( "grrUi.core.resultsCollectionDirective.setAutoRefreshInterval(1000);" ) self.Click("css=a[grrtarget=hunts]") self.Click("css=td:contains('GenericHunt')") self.Click("css=li[heading=Results]") self.WaitUntil(self.IsElementPresent, "css=grr-results-collection td:contains('foo-result')") self.WaitUntilNot( self.IsElementPresent, "css=grr-results-collection td:contains('bar-result')") with data_store.DB.GetMutationPool() as pool: h.ResultCollection().Add(rdf_flows.GrrMessage( payload=rdfvalue.RDFString("bar-result"), source=client_id), mutation_pool=pool) self.WaitUntil(self.IsElementPresent, "css=grr-results-collection td:contains('bar-result')")
def Run(self): hunt_urn = rdfvalue.RDFURN("aff4:/hunts/H:123456") results = implementation.GRRHunt.ResultCollectionForHID(hunt_urn) with data_store.DB.GetMutationPool() as pool: result = rdf_flows.GrrMessage( payload=rdfvalue.RDFString("blah1"), age=rdfvalue.RDFDatetime.FromSecondsSinceEpoch(1)) results.Add(result, timestamp=result.age + rdfvalue.Duration("1s"), mutation_pool=pool) result = rdf_flows.GrrMessage( payload=rdfvalue.RDFString("blah2-foo"), age=rdfvalue.RDFDatetime.FromSecondsSinceEpoch(42)) results.Add(result, timestamp=result.age + rdfvalue.Duration("1s"), mutation_pool=pool) self.Check("ListHuntResults", args=hunt_plugin.ApiListHuntResultsArgs(hunt_id="H:123456")) self.Check("ListHuntResults", args=hunt_plugin.ApiListHuntResultsArgs(hunt_id="H:123456", count=1)) self.Check("ListHuntResults", args=hunt_plugin.ApiListHuntResultsArgs(hunt_id="H:123456", offset=1, count=1)) self.Check("ListHuntResults", args=hunt_plugin.ApiListHuntResultsArgs(hunt_id="H:123456", filter="foo"))
def testLengthOfCollectionIsCorrectWhenMultipleTypesAreUsed(self): with self.pool: for i in range(100): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString(i)), mutation_pool=self.pool) self.assertEqual(200, len(self.collection))
def testEqualTimestampNotifications(self): frontend_server = frontend_lib.FrontEndServer( certificate=config.CONFIG["Frontend.certificate"], private_key=config.CONFIG["PrivateKeys.server_key"], message_expiry_time=100, threadpool_prefix="notification-test") # This schedules 10 requests. session_id = flow.StartFlow(client_id=self.client_id, flow_name="WorkerSendingTestFlow", token=self.token) # We pretend that the client processed all the 10 requests at once and # sends the replies in a single http poll. messages = [ rdf_flows.GrrMessage( request_id=i, response_id=1, session_id=session_id, payload=rdf_protodict.DataBlob(string="test%s" % i), auth_state="AUTHENTICATED", generate_task_id=True) for i in range(1, 11) ] status = rdf_flows.GrrStatus( status=rdf_flows.GrrStatus.ReturnedStatus.OK) statuses = [ rdf_flows.GrrMessage(request_id=i, response_id=2, session_id=session_id, payload=status, type=rdf_flows.GrrMessage.Type.STATUS, auth_state="AUTHENTICATED", generate_task_id=True) for i in range(1, 11) ] frontend_server.ReceiveMessages(self.client_id, messages + statuses) with queue_manager.QueueManager(token=self.token) as q: all_notifications = q.GetNotificationsByPriorityForAllShards( rdfvalue.RDFURN("aff4:/F")) medium_priority = rdf_flows.GrrNotification.Priority.MEDIUM_PRIORITY medium_notifications = all_notifications[medium_priority] my_notifications = [ n for n in medium_notifications if n.session_id == session_id ] # There must not be more than one notification. self.assertEqual(len(my_notifications), 1) notification = my_notifications[0] self.assertEqual(notification.first_queued, notification.timestamp) self.assertEqual(notification.last_status, 10)
def testStoresEmptyGrrMessage(self): with self.pool: self.collection.Add(rdf_flows.GrrMessage(), mutation_pool=self.pool) self.assertListEqual([rdf_flows.GrrMessage.__name__], list(self.collection.ListStoredTypes()))
def testLengthIsReportedCorrectlyForEveryType(self): with self.pool: for i in range(99): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)), mutation_pool=self.pool) for i in range(101): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString(i)), mutation_pool=self.pool) self.assertEqual( 99, self.collection.LengthByType(rdfvalue.RDFInteger.__name__)) self.assertEqual( 101, self.collection.LengthByType(rdfvalue.RDFString.__name__))
def ProcessResponses(self, plugin_args=None, responses=None, process_responses_separately=False): plugin = bigquery_plugin.BigQueryOutputPlugin( source_urn=self.results_urn, output_base_urn=self.base_urn, args=plugin_args, token=self.token) plugin.InitializeState() messages = [] for response in responses: messages.append( rdf_flows.GrrMessage(source=self.client_id, payload=response)) with test_lib.FakeTime(1445995873): with mock.patch.object(bigquery, "GetBigQueryClient") as mock_bigquery: if process_responses_separately: for message in messages: plugin.ProcessResponses([message]) else: plugin.ProcessResponses(messages) plugin.Flush() return [ x[0] for x in mock_bigquery.return_value.InsertData.call_args_list ]
def _SendTerminationMessage(self, status=None): """This notifies the parent flow of our termination.""" if not self.runner_args.request_state.session_id: # No parent flow, nothing to do here. return if status is None: status = rdf_flows.GrrStatus() client_resources = self.context.client_resources user_cpu = client_resources.cpu_usage.user_cpu_time sys_cpu = client_resources.cpu_usage.system_cpu_time status.cpu_time_used.user_cpu_time = user_cpu status.cpu_time_used.system_cpu_time = sys_cpu status.network_bytes_sent = self.context.network_bytes_sent status.child_session_id = self.session_id request_state = self.runner_args.request_state request_state.response_count += 1 # Make a response message msg = rdf_flows.GrrMessage( session_id=request_state.session_id, request_id=request_state.id, response_id=request_state.response_count, auth_state=rdf_flows.GrrMessage.AuthorizationState.AUTHENTICATED, type=rdf_flows.GrrMessage.Type.STATUS, payload=status) # Queue the response now self.queue_manager.QueueResponse(msg) self.QueueNotification(session_id=request_state.session_id)
def Execute(self, action_cls, args): responses = list() def SendReply(value, session_id=None, message_type=rdf_flows.GrrMessage.Type.MESSAGE): if message_type != rdf_flows.GrrMessage.Type.MESSAGE: return if str(session_id) in self.wkfs: message = rdf_flows.GrrMessage(name=action_cls.__name__, payload=value, auth_state="AUTHENTICATED", session_id=session_id) self.wkfs[str(session_id)].ProcessMessage(message) else: responses.append(value) message = rdf_flows.GrrMessage(name=action_cls.__name__, payload=args, auth_state="AUTHENTICATED", session_id=rdfvalue.SessionID()) action = action_cls(grr_worker=worker_mocks.FakeClientWorker()) action.SendReply = SendReply action.Execute(message) return responses
def testWellKnownFlows(self): """Test the well known flows.""" test_flow = self.FlowSetup(flow_test_lib.WellKnownSessionTest.__name__) # Make sure the session ID is well known self.assertEqual( test_flow.session_id, flow_test_lib.WellKnownSessionTest.well_known_session_id) # Messages to Well Known flows can be unauthenticated messages = [ rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)) for i in range(10) ] for message in messages: test_flow.ProcessMessage(message) # The messages might be processed in arbitrary order test_flow.messages.sort() # Make sure that messages were processed even without a status # message to complete the transaction (Well known flows do not # have transactions or states - all messages always get to the # ProcessMessage method): self.assertEqual(test_flow.messages, range(10))
def testUnauthenticated(self): """What happens if an unauthenticated message is sent to the client? RuntimeError needs to be issued, and the client needs to send a GrrStatus message with the traceback in it. """ # Push a request on it message = rdf_flows.GrrMessage( name="MockAction", session_id=self.session_id, auth_state=rdf_flows.GrrMessage.AuthorizationState.UNAUTHENTICATED, request_id=1, generate_task_id=True) self.context.HandleMessage(message) # We expect to receive an GrrStatus to indicate an exception was # raised: # Check the response - one data and one status message_list = self.context.Drain().job self.assertEqual(len(message_list), 1) self.assertEqual(message_list[0].session_id, self.session_id) self.assertEqual(message_list[0].response_id, 1) status = rdf_flows.GrrStatus(message_list[0].payload) self.assertIn("not Authenticated", status.error_message) self.assertIn("RuntimeError", status.error_message) self.assertNotEqual(status.status, rdf_flows.GrrStatus.ReturnedStatus.OK)
def testDelete(self): """Test that we can delete tasks.""" test_queue = rdfvalue.RDFURN("fooDelete") task = rdf_flows.GrrMessage( queue=test_queue, session_id="aff4:/Test", generate_task_id=True) with data_store.DB.GetMutationPool() as pool: manager = queue_manager.QueueManager(token=self.token) manager.Schedule([task], pool) # Get a lease on the task tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].session_id, "aff4:/Test") # Now delete the task with data_store.DB.GetMutationPool() as pool: manager.Delete(test_queue, tasks, mutation_pool=pool) # Task is now deleted. tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 0) # If we try to get another lease on it we should fail - even after # expiry time. self._current_mock_time += 1000 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 0)
def testCountsActualNumberOfCompletedResponsesWhenApplyingTheLimit(self): session_id = rdfvalue.SessionID(flow_name="test") # Now queue more requests and responses: with queue_manager.QueueManager(token=self.token) as manager: # Start with request 1 - leave request 1 un-responded to. for request_id in range(5): request = rdf_flow_runner.RequestState( id=request_id, client_id=test_lib.TEST_CLIENT_ID, next_state="TestState", session_id=session_id) manager.QueueRequest(request) # Don't queue any actual responses, just a status message with a # fake response_id. manager.QueueResponse( rdf_flows.GrrMessage( session_id=session_id, request_id=request_id, response_id=1000, type=rdf_flows.GrrMessage.Type.STATUS)) # Check that even though status message for every request indicates 1000 # responses, only the actual response count is used to apply the limit # when FetchCompletedResponses is called. completed_response = list( manager.FetchCompletedResponses(session_id, limit=5)) self.assertEqual(len(completed_response), 5) for i, (request, responses) in enumerate(completed_response): self.assertEqual(request.id, i) # Responses contain just the status message. self.assertEqual(len(responses), 1)
def testSchedule(self): """Test the ability to schedule a task.""" test_queue = rdfvalue.RDFURN("fooSchedule") task = rdf_flows.GrrMessage( queue=test_queue, task_ttl=5, session_id="aff4:/Test", generate_task_id=True) manager = queue_manager.QueueManager(token=self.token) with data_store.DB.GetMutationPool() as pool: manager.Schedule([task], pool) self.assertGreater(task.task_id, 0) self.assertGreater(task.task_id & 0xffffffff, 0) self.assertEqual((long(self._current_mock_time * 1000) & 0xffffffff) << 32, task.task_id & 0x1fffffff00000000) self.assertEqual(task.task_ttl, 5) stored_tasks = data_store.DB.QueueQueryTasks(test_queue, limit=100000) self.assertEqual(len(stored_tasks), 1) stored_task = stored_tasks[0] self.assertGreater(stored_task.leased_until, 0) stored_task.leased_until = None self.assertRDFValuesEqual(stored_task, task) # Get a lease on the task tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].task_ttl, 4) self.assertEqual(tasks[0].session_id, "aff4:/Test") # If we try to get another lease on it we should fail self._current_mock_time += 10 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 0) # However after 100 seconds this should work again self._current_mock_time += 110 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].task_ttl, 3) # Check now that after a few retransmits we drop the message for i in range(2, 0, -1): self._current_mock_time += 110 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].task_ttl, i) # The task is now gone self._current_mock_time += 110 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100) self.assertEqual(len(tasks), 0)
def testTaskRetransmissionsAreCorrectlyAccounted(self): test_queue = rdfvalue.RDFURN("fooSchedule") task = rdf_flows.GrrMessage( queue=test_queue, task_ttl=5, session_id="aff4:/Test", generate_task_id=True) manager = queue_manager.QueueManager(token=self.token) with data_store.DB.GetMutationPool() as pool: manager.Schedule([task], pool) # Get a lease on the task tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].task_ttl, 4) self.assertEqual( stats.STATS.GetMetricValue("grr_task_retransmission_count"), self.retransmission_metric_value) # Get a lease on the task 100 seconds later self._current_mock_time += 110 tasks = manager.QueryAndOwn(test_queue, lease_seconds=100, limit=100) self.assertEqual(len(tasks), 1) self.assertEqual(tasks[0].task_ttl, 3) self.assertEqual( stats.STATS.GetMetricValue("grr_task_retransmission_count"), self.retransmission_metric_value + 1)
def testNotificationClaimsTimeout(self): collection_urn = rdfvalue.RDFURN( "aff4:/testNotificationClaimsTimeout/collection") with data_store.DB.GetMutationPool() as pool: for i in range(5): hunts_results.HuntResultCollection.StaticAdd( collection_urn, rdf_flows.GrrMessage(request_id=i), mutation_pool=pool) results_1 = hunts_results.HuntResultQueue.ClaimNotificationsForCollection( token=self.token) self.assertEqual(5, len(results_1[1])) # Check that we have a claim - that another read returns nothing. results_2 = hunts_results.HuntResultQueue.ClaimNotificationsForCollection( token=self.token) self.assertEqual(0, len(results_2[1])) # Push time forward past the default claim timeout, then we should be able # to re-read (and re-claim). with test_lib.FakeTime(rdfvalue.RDFDatetime.Now() + rdfvalue.Duration("45m")): results_3 = hunts_results.HuntResultQueue.ClaimNotificationsForCollection( token=self.token) self.assertEqual(results_3, results_1)
def ProcessResponses(self, plugin_args=None, responses=None, process_responses_separately=False): plugin = email_plugin.EmailOutputPlugin(source_urn=self.results_urn, args=plugin_args, token=self.token) plugin.InitializeState() messages = [] for response in responses: messages.append( rdf_flows.GrrMessage(source=self.client_id, payload=response)) def SendEmail(address, sender, title, message, **_): self.email_messages.append( dict(address=address, sender=sender, title=title, message=message)) with utils.Stubber(email_alerts.EMAIL_ALERTER, "SendEmail", SendEmail): if process_responses_separately: for message in messages: plugin.ProcessResponses([message]) else: plugin.ProcessResponses(messages) plugin.Flush()
def ProcessValues(self, values_by_cls): chunks = [] chunks.extend(list(self.plugin.Start())) for value_cls in sorted(values_by_cls, key=lambda cls: cls.__name__): values = values_by_cls[value_cls] messages = [] for value in values: messages.append( rdf_flows.GrrMessage(source=self.client_id, payload=value)) # pylint: disable=cell-var-from-loop chunks.extend( list(self.plugin.ProcessValues(value_cls, lambda: messages))) # pylint: enable=cell-var-from-loop chunks.extend(list(self.plugin.Finish())) fd_path = os.path.join(self.temp_dir, self.plugin.output_file_name) with open(fd_path, "wb") as fd: for chunk in chunks: fd.write(chunk) return fd_path
def CreateGenericHuntWithCollection(self, values=None): self.client_ids = self.SetupClients(10) CreateFileVersion(self.client_ids[0], "fs/os/c/bin/bash", token=self.token) if values is None: values = [ rdfvalue.RDFURN("aff4:/sample/1"), rdfvalue.RDFURN("aff4:/%s/fs/os/c/bin/bash" % self.client_ids[0].Basename()), rdfvalue.RDFURN("aff4:/sample/3") ] with implementation.GRRHunt.StartHunt( hunt_name=standard.GenericHunt.__name__, client_rule_set=self._CreateForemanClientRuleSet(), output_plugins=[], token=self.token) as hunt: runner = hunt.GetRunner() runner.Start() collection = hunt.ResultCollection() with data_store.DB.GetMutationPool() as pool: for value in values: collection.Add(rdf_flows.GrrMessage( payload=value, source=self.client_ids[0]), mutation_pool=pool) return hunt.urn
def testDeleteRequest(self): """Check that we can efficiently destroy a single flow request.""" session_id = rdfvalue.SessionID(flow_name="test3") request = rdf_flow_runner.RequestState( id=1, client_id=test_lib.TEST_CLIENT_ID, next_state="TestState", session_id=session_id) with queue_manager.QueueManager(token=self.token) as manager: manager.QueueRequest(request) manager.QueueResponse( rdf_flows.GrrMessage( session_id=session_id, request_id=1, response_id=1)) # Check the request and responses are there. all_requests = list(manager.FetchRequestsAndResponses(session_id)) self.assertEqual(len(all_requests), 1) self.assertEqual(all_requests[0][0], request) with queue_manager.QueueManager(token=self.token) as manager: manager.DeleteRequest(request) all_requests = list(manager.FetchRequestsAndResponses(session_id)) self.assertEqual(len(all_requests), 0)
def StaticAdd(cls, collection_urn, rdf_value, timestamp=None, suffix=None, mutation_pool=None): """Adds an rdf value to a collection. Adds an rdf value to a collection. Does not require that the collection be open. NOTE: The caller is responsible for ensuring that the collection exists and is of the correct type. Args: collection_urn: The urn of the collection to add to. rdf_value: The rdf value to add to the collection. If this value is not GrrMessage, it will be wrapped into GrrMessage (later when collection is iterated, this value will still be returned wrapped in GrrMessage). timestamp: The timestamp (in microseconds) to store the rdf value at. Defaults to the current time. suffix: A 'fractional timestamp' suffix to reduce the chance of collisions. Defaults to a random number. mutation_pool: A MutationPool object to write to. Returns: The pair (timestamp, suffix) which identifies the value within the collection. Raises: ValueError: rdf_value has unexpected type. """ if rdf_value is None: raise ValueError("Can't add None to MultiTypeCollection") if mutation_pool is None: raise ValueError("Mutation pool can't be none.") if not isinstance(rdf_value, rdf_flows.GrrMessage): rdf_value = rdf_flows.GrrMessage(payload=rdf_value) value_type = rdf_value.args_rdf_name or rdf_flows.GrrMessage.__name__ # In order to make this fast, we never actually generate the # subcollections, we just use them. This means that we cannot use # ListChildren to get all the items stored in this # MultiTypeCollection. subpath = collection_urn.Add(value_type) sequential_collection.GrrMessageCollection.StaticAdd( subpath, rdf_value, timestamp=timestamp, suffix=suffix, mutation_pool=mutation_pool) mutation_pool.CollectionAddStoredTypeIndex(collection_urn, value_type)
def testExtractsTypesFromGrrMessage(self): with self.pool: self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(0)), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString("foo")), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFURN("aff4:/foo/bar")), mutation_pool=self.pool) self.assertEqual( set([ rdfvalue.RDFInteger.__name__, rdfvalue.RDFString.__name__, rdfvalue.RDFURN.__name__ ]), set(self.collection.ListStoredTypes()))
def testValuesOfMultipleTypesCanBeIteratedPerType(self): with self.pool: for i in range(100): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString(i)), mutation_pool=self.pool) for index, (_, v) in enumerate( self.collection.ScanByType(rdfvalue.RDFInteger.__name__)): self.assertEqual(index, v.payload) for index, (_, v) in enumerate( self.collection.ScanByType(rdfvalue.RDFString.__name__)): self.assertEqual(str(index), v.payload)
def testValuesOfMultipleTypesCanBeIteratedTogether(self): with self.pool: original_values = set() for i in range(100): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)), mutation_pool=self.pool) original_values.add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i))) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString(i)), mutation_pool=self.pool) original_values.add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString(i))) self.assertEqual(sorted([v.payload for v in original_values]), sorted([v.payload for v in self.collection]))
def testValuesOfSingleTypeAreAddedAndIterated(self): with self.pool: for i in range(100): self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(i)), mutation_pool=self.pool) for index, v in enumerate(self.collection): self.assertEqual(index, v.payload)
def SendReply(self, rdf_value, message_type=rdf_flows.GrrMessage.Type.MESSAGE, **kw): message = rdf_flows.GrrMessage(type=message_type, payload=rdf_value, **kw) self.responses.append(message)
def testDeletingCollectionDeletesAllSubcollections(self): if not isinstance(data_store.DB, fake_data_store.FakeDataStore): self.skipTest("Only supported on FakeDataStore.") with self.pool: self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFInteger(0)), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFString("foo")), mutation_pool=self.pool) self.collection.Add( rdf_flows.GrrMessage(payload=rdfvalue.RDFURN("aff4:/foo/bar")), mutation_pool=self.pool) self.collection.Delete() for urn in data_store.DB.subjects.keys(): self.assertFalse( utils.SmartStr(self.collection.collection_id) in urn)
def ExecuteAction(self, action_cls, arg=None, grr_worker=None): message = rdf_flows.GrrMessage( name=action_cls.__name__, payload=arg, auth_state="AUTHENTICATED") self.results = [] action = self._GetActionInstance(action_cls, grr_worker=grr_worker) action.Execute(message) return self.results
def testLinuxTransactionLog(self): """Tests the linux transaction log.""" with tempfile.NamedTemporaryFile() as fd: log = client_utils_linux.TransactionLog(logfile=fd.name) grr_message = rdf_flows.GrrMessage(session_id="W:test") log.Write(grr_message) self.assertRDFValuesEqual(grr_message, log.Get()) log.Clear() self.assertIsNone(log.Get())