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)
