def Layout(self, request, response): """Display the overview.""" if not self.hunt_id: self.hunt_id = request.REQ.get("hunt_id") h = dict(main="ManageHuntsClientView", hunt_id=self.hunt_id) self.hash = urllib.urlencode(sorted(h.items())) self.data = {} self.args_str = "" if self.hunt_id: try: self.hunt = aff4.FACTORY.Open(self.hunt_id, aff4_type=implementation.GRRHunt, token=request.token) hunt_stats = self.hunt.context.usage_stats self.cpu_sum = "%.2f" % hunt_stats.user_cpu_stats.sum self.net_sum = hunt_stats.network_bytes_sent_stats.sum (self.all_clients_count, self.completed_clients_count, _) = self.hunt.GetClientsCounts() self.outstanding_clients_count = (self.all_clients_count - self.completed_clients_count) runner = self.hunt.GetRunner() self.hunt_name = runner.runner_args.hunt_name self.hunt_creator = runner.context.creator self.data = py_collections.OrderedDict() self.data["Start Time"] = runner.context.start_time self.data["Expiry Time"] = runner.context.expires self.data["Status"] = self.hunt.Get(self.hunt.Schema.STATE) self.client_limit = runner.runner_args.client_limit self.client_rate = runner.runner_args.client_rate renderer = semantic.FindRendererForObject(self.hunt.args) self.args_str = renderer.RawHTML(request) renderer = semantic.FindRendererForObject( self.hunt.runner_args) self.runner_args_str = renderer.RawHTML(request) if runner.runner_args.client_rule_set: self.client_rule_set = foreman.RuleArray( runner.runner_args.client_rule_set).RawHTML(request) else: self.client_rule_set = "None" except IOError: self.layout_template = self.error_template return super(AbstractLogRenderer, self).Layout(request, response)
def FindRendererForObject(rdf_obj): """A proxy method for semantic.FindRendererForObject.""" # pylint: disable=g-import-not-at-top, unused-variable, redefined-outer-name from grr.gui.plugins import semantic # pylint: enable=g-import-not-at-top, unused-variable, redefined-outer-name return semantic.FindRendererForObject(rdf_obj)
def Layout(self, request, response): """Render the protobuf as a table.""" self.result = [] for descriptor, value in self.proxy.ListSetFields(): name = descriptor.name friendly_name = descriptor.friendly_name or name if name == "total_allocation_units" and value is not None: value_str = "{0} ({1:.2f} GB)".format( value, self.proxy.AUToGBytes(value)) self.result.append( (friendly_name, descriptor.description, value_str)) elif name == "actual_available_allocation_units" and value is not None: value_str = "{0} ({1:.2f} GB, {2:.0f}% free)".format( value, self.proxy.AUToGBytes(value), self.proxy.FreeSpacePercent()) self.result.append( (friendly_name, descriptor.description, value_str)) else: renderer = semantic.FindRendererForObject(value) self.result.append((friendly_name, descriptor.description, renderer.RawHTML(request))) return super(semantic.RDFProtoRenderer, self).Layout(request, response)
def Layout(self, request, response): if self.proxy.session_id: self.hash = urllib.urlencode( dict(c=self.proxy.client_id, flow=self.proxy.session_id, main="ManageFlows")) client_info_renderer = semantic.FindRendererForObject( self.proxy.client_info) self.client_info = client_info_renderer.RawHTML(request) super(ClientCrashDetailsRenderer, self).Layout(request, response)
def RenderAjax(self, request, response): """Parse the flow args from the form and launch the flow.""" self.flow_name = self._GetFlowName(request) self.client_id = request.REQ.get("client_id", None) self.dom_node = request.REQ.get("dom_node") flow_cls = flow.GRRFlow.classes.get(self.flow_name) if flow_cls is not None: self.args = forms.SemanticProtoFormRenderer( flow_cls.args_type(), prefix="args").ParseArgs(request) try: self.args.Validate() except ValueError as e: return self.CallJavascript( response, "SemanticProtoFlowForm.RenderAjaxError", error=str(e)) self.runner_args = forms.SemanticProtoFormRenderer( flow_runner.FlowRunnerArgs(), prefix="runner_").ParseArgs(request) self.runner_args.Validate() self.flow_id = flow.GRRFlow.StartFlow(client_id=self.client_id, flow_name=self.flow_name, token=request.token, args=self.args, runner_args=self.runner_args) self.args_html = semantic.FindRendererForObject( self.args).RawHTML(request) self.runner_args_html = semantic.FindRendererForObject( self.runner_args).RawHTML(request) response = renderers.TemplateRenderer.Layout( self, request, response, apply_template=self.ajax_template) return self.CallJavascript(response, "SemanticProtoFlowForm.RenderAjax", renderer=self.__class__.__name__, dom_node=self.dom_node)
def Layout(self, request, response): """Fill in the form with the specific fields for the flow requested.""" self.log = [] for row in self.GetLog(request): rendered_row = [] for item in row: item_renderer = semantic.FindRendererForObject(item) rendered_row.append(item_renderer.RawHTML(request)) self.log.append(rendered_row) return super(AbstractLogRenderer, self).Layout(request, response)
def Layout(self, request, response): """Layout.""" if request.REQ.get("task_id") is None: return client_id = rdf_client.ClientURN(request.REQ.get("client_id")) task_id = "task:" + request.REQ.get("task_id") # Make a local QueueManager. manager = queue_manager.QueueManager(token=request.token) msgs = manager.Query(client_id, task_id=task_id) if msgs: self.msg = msgs[0] self.view = semantic.FindRendererForObject( self.msg).RawHTML(request) return super(RequestRenderer, self).Layout(request, response)
def RenderAFF4Attributes(self, fd, request=None): """Returns attributes rendered by class.""" classes = [] attribute_names = set() for flow_cls in fd.__class__.__mro__: if not hasattr(flow_cls, "SchemaCls"): continue schema = flow_cls.SchemaCls attributes = [] for name, attribute in sorted(schema.__dict__.items()): if not isinstance(attribute, aff4.Attribute): continue # If we already showed this attribute we move on if attribute.predicate in attribute_names: continue values = list(fd.GetValuesForAttribute(attribute)) multi = len(values) > 1 if values: attribute_names.add(attribute.predicate) value_renderer = semantic.FindRendererForObject(values[0]) if self.attributes_to_show and name not in self.attributes_to_show: continue attributes.append((name, attribute.description, # This is assumed to be in safe RawHTML and not # escaped. value_renderer.RawHTML(request), rdfvalue.RDFDatetime(values[0].age), multi)) if attributes: classes.append((flow_cls.__name__, attributes)) return classes
def RenderPayload(self, request, unused_value): rdf_object = self.proxy.payload return semantic.FindRendererForObject(rdf_object).RawHTML(request)