Example #1
0
    def Run(self, arg):
        """Returns the client stats."""
        if arg is None:
            arg = rdfvalue.GetClientStatsRequest()

        proc = psutil.Process(os.getpid())
        meminfo = proc.memory_info()
        response = rdfvalue.ClientStats(
            RSS_size=meminfo[0],
            VMS_size=meminfo[1],
            memory_percent=proc.memory_percent(),
            bytes_received=stats.STATS.GetMetricValue(
                "grr_client_received_bytes"),
            bytes_sent=stats.STATS.GetMetricValue("grr_client_sent_bytes"),
            create_time=long(proc.create_time() * 1e6),
            boot_time=long(psutil.boot_time() * 1e6))

        samples = self.grr_worker.stats_collector.cpu_samples
        for (timestamp, user, system, percent) in samples:
            if arg.start_time < timestamp < arg.end_time:
                sample = rdfvalue.CpuSample(timestamp=timestamp,
                                            user_cpu_time=user,
                                            system_cpu_time=system,
                                            cpu_percent=percent)
                response.cpu_samples.Append(sample)

        samples = self.grr_worker.stats_collector.io_samples
        for (timestamp, read_bytes, write_bytes) in samples:
            if arg.start_time < timestamp < arg.end_time:
                sample = rdfvalue.IOSample(timestamp=timestamp,
                                           read_bytes=read_bytes,
                                           write_bytes=write_bytes)
                response.io_samples.Append(sample)

        self.Send(response)
Example #2
0
            def GetClientStats(self, _):
                """Fake get client stats method."""
                response = rdfvalue.ClientStats()
                for i in range(12):
                    sample = rdfvalue.CpuSample(timestamp=int(i * 10 * 1e6),
                                                user_cpu_time=10 + i,
                                                system_cpu_time=20 + i,
                                                cpu_percent=10 + i)
                    response.cpu_samples.Append(sample)

                    sample = rdfvalue.IOSample(timestamp=int(i * 10 * 1e6),
                                               read_bytes=10 + i,
                                               write_bytes=10 + i)
                    response.io_samples.Append(sample)

                return [response]
Example #3
0
    def FillClientStats(
            client_id=rdfvalue.ClientURN("C.0000000000000001"), token=None):
        for minute in range(6):
            stats = rdfvalue.ClientStats()
            for i in range(minute * 60, (minute + 1) * 60):
                sample = rdfvalue.CpuSample(timestamp=int(i * 10 * 1e6),
                                            user_cpu_time=10 + i,
                                            system_cpu_time=20 + i,
                                            cpu_percent=10 + i)
                stats.cpu_samples.Append(sample)

                sample = rdfvalue.IOSample(timestamp=int(i * 10 * 1e6),
                                           read_bytes=10 + i,
                                           write_bytes=10 + i * 2)
                stats.io_samples.Append(sample)

            message = rdfvalue.GrrMessage(source=client_id,
                                          args=stats.SerializeToString())
            flow.WellKnownFlow.GetAllWellKnownFlows(
                token=token)["Stats"].ProcessMessage(message)