Exemple #1
0
    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000.
        self._mongo_ops = MongoOps(self._connection)
Exemple #2
0
    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000.0
        self._mongo_ops = MongoOps(self._connection)
Exemple #3
0
class Runner:
    """
    Main logic for 'mtop'. Once initialized, L{run()} keeps updating
    until ctrl-c is pressed.
    """
    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000.
        self._mongo_ops = MongoOps(self._connection)

    def run(self):
        """
        Run loop.

        @param screen: cursus screen object.
        @return: 0 if normal exit, negative values otherwise
        """

        self._screen = Screen()
        try:
            return self._do_run()
        except KeyboardInterrupt:
            pass
        finally:
            self._screen.end()

        return 0

    def _do_run(self):
        self._screen.timeout(self._timeout)
        self._last_opstats = {}
        self._maxy, self._maxx = self._screen.getmaxyx()

        if self._maxy < 5:
            return -3

        while True:
            self._y = 0

            srvstat = self._mongo_ops.get_server_status()
            inprog = self._mongo_ops.get_inprog()
            inprog.sort(op_cmp)

            self._screen.clear()
            if srvstat:
                self._server_stats(srvstat)
                self._memory_stats(srvstat)
                self._repl_stats(srvstat)
                self._op_stats(srvstat)

            if inprog:
                self._inprog(inprog)

            time.sleep(self._timeout)

            # In the event of a resize
            self._maxy, self._maxx = self._screen.getmaxyx()

    def _print(self, arr):
        try:
            self._screen.addstr(self._y, 0, ''.join(arr)[:self._maxx])
            self._y += 1
        except:
            pass

    def _server_stats(self, d):
        host = self._connection.host
        out = []
        out.append("%s. v%s, %d bit" % (host, d['version'], d['mem']['bits']))
        out.append(
            '. Conns: %d/%d' %
            (d['connections']['current'], d['connections']['available']))
        ratio = d['globalLock'].get('ratio')
        if ratio is None:
            ratio = float(d['globalLock']['lockTime']) / float(
                d['globalLock']['totalTime'])
        out.append('. Lock %%: %.2f' % round(ratio, 2))
        self._print(out)

    def _memory_stats(self, d):
        out = []
        out.append(
            'Mem (MB): %s resident, %s virtual, %s mapped' %
            (d['mem']['resident'], d['mem']['virtual'], d['mem']['mapped']))
        if 'workingSet' in d:
            # value is in pages (i.e. 4k blocks), so divide it by / 256 to get MB
            out.append(', %d working set' %
                       (round(int(d['workingSet']['pagesInMemory']) / 256.0)))
        self._print(out)

    def _repl_stats(self, d):
        repl = d.get('repl')
        if not repl:
            return

        hosts = repl.get('hosts')
        if not hosts:
            return

        out = []
        out.append('Rep (%s):' % repl['setName'])
        for host in hosts:
            out.append(' %s(%s)' %
                       (host, 'P' if host == repl['primary'] else 'S'))
        self._print(out)

    def _op_stats(self, d):
        out = []
        out.append('Ops:')
        ops = []
        total = 0
        for op in d['opcounters']:
            val = 0
            if op in self._last_opstats:
                val = d['opcounters'][op] - self._last_opstats[op]
            self._last_opstats[op] = d['opcounters'][op]
            ops.append(' %4d %s' % (val, op))
            total += val

        ops.insert(0, ' %4d total' % total)
        out.append(','.join(ops))
        self._print(out)

    def _inprog(self, inprog):
        template = "%11s %21s %7s %1s %5s %s"
        self._print([template % ('ID', 'CLIENT', 'OP', 'A', 'LOCKW', 'NS')])

        opsmax = self._maxy - self._y
        if len(inprog) > opsmax:
            # Leave room for '% more' line
            opsmax -= 1

        for op in inprog[:opsmax]:
            a = 'T' if op['active'] else 'F'
            lock = op.get('lockType') if op['waitingForLock'] else ''
            self._print([
                template %
                (op['opid'], op['client'], op['op'], a, lock, op['ns'])
            ])

        if len(inprog) > opsmax:
            self._print(['( ... %d more ... )' % (len(inprog) - opsmax)])
Exemple #4
0
class Runner:
    """
    Main logic for 'mtop'. Once initialized, L{run()} keeps updating
    until ctrl-c is pressed.
    """

    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000.0
        self._mongo_ops = MongoOps(self._connection)

    def run(self):
        """
        Run loop.

        @param screen: cursus screen object.
        @return: 0 if normal exit, negative values otherwise
        """

        self._screen = Screen()
        try:
            return self._do_run()
        except KeyboardInterrupt:
            pass
        finally:
            self._screen.end()

        return 0

    def _do_run(self):
        self._screen.timeout(self._timeout)
        self._last_opstats = {}
        self._maxy, self._maxx = self._screen.getmaxyx()

        if self._maxy < 5:
            return -3

        while True:
            self._y = 0

            srvstat = self._mongo_ops.get_server_status()
            inprog = self._mongo_ops.get_inprog()
            inprog.sort(op_cmp)

            self._screen.clear()
            if srvstat:
                self._server_stats(srvstat)
                self._memory_stats(srvstat)
                self._repl_stats(srvstat)
                self._op_stats(srvstat)

            if inprog:
                self._inprog(inprog)

            time.sleep(self._timeout)

            # In the event of a resize
            self._maxy, self._maxx = self._screen.getmaxyx()

    def _print(self, arr):
        try:
            self._screen.addstr(self._y, 0, "".join(arr)[: self._maxx])
            self._y += 1
        except:
            pass

    def _server_stats(self, d):
        host = self._connection.host
        out = []
        out.append("%s. v%s, %d bit" % (host, d["version"], d["mem"]["bits"]))
        out.append(". Conns: %d/%d" % (d["connections"]["current"], d["connections"]["available"]))
        out.append(". Lock %%: %.2f" % round(float(d["globalLock"]["ratio"]), 2))
        self._print(out)

    def _memory_stats(self, d):
        self._print(
            [
                "Mem: %s resident, %s virtual, %s mapped"
                % (d["mem"]["resident"], d["mem"]["virtual"], d["mem"]["mapped"])
            ]
        )

    def _repl_stats(self, d):
        repl = d.get("repl")
        if not repl or repl["ismaster"] != 0:
            return

        sources = repl.get("sources")
        if not sources:
            return

        out = []
        out.append("Rep:")
        for source in sources:
            out.append(" %s: %ds" % (source["host"], source["lagSeconds"]))
        self._print(out)

    def _op_stats(self, d):
        out = []
        out.append("Ops:")
        ops = []
        total = 0
        for op in d["opcounters"]:
            val = 0
            if op in self._last_opstats:
                val = d["opcounters"][op] - self._last_opstats[op]
            self._last_opstats[op] = d["opcounters"][op]
            ops.append(" %4d %s" % (val, op))
            total += val

        ops.insert(0, " %4d total" % total)
        out.append(",".join(ops))
        self._print(out)

    def _inprog(self, inprog):
        template = "%11s %21s %7s %1s %5s %s"
        self._print([template % ("ID", "CLIENT", "OP", "A", "LOCKW", "NS")])

        opsmax = self._maxy - self._y
        if len(inprog) > opsmax:
            # Leave room for '% more' line
            opsmax -= 1

        for op in inprog[:opsmax]:
            a = "T" if op["active"] else "F"
            lock = op["lockType"] if op["waitingForLock"] else ""
            self._print([template % (op["opid"], op["client"], op["op"], a, lock, op["ns"])])

        if len(inprog) > opsmax:
            self._print(["( ... %d more ... )" % (len(inprog) - opsmax)])
Exemple #5
0
class Runner:
    """
    Main logic for 'mtop'. Once initialized, L{run()} keeps updating
    until ctrl-c is pressed.
    """

    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000.
        self._mongo_ops = MongoOps(self._connection)

    def run(self):
        """
        Run loop.

        @param screen: cursus screen object.
        @return: 0 if normal exit, negative values otherwise
        """

        self._screen = Screen()
        try:
            return self._do_run()
        except KeyboardInterrupt:
            pass
        finally:
            self._screen.end()

        return 0

    def _do_run(self):
        self._screen.timeout(self._timeout)
        self._last_opstats = {}
        self._maxy, self._maxx = self._screen.getmaxyx()

        if self._maxy < 5:
            return -3

        while True:
            self._y = 0

            srvstat = self._mongo_ops.get_server_status()
            inprog = self._mongo_ops.get_inprog()
            inprog.sort(op_cmp)

            self._screen.clear()
            if srvstat:
                self._server_stats(srvstat)
                self._memory_stats(srvstat)
                self._repl_stats(srvstat)
                self._op_stats(srvstat)

            if inprog:
                self._inprog(inprog)

            time.sleep(self._timeout)

            # In the event of a resize
            self._maxy, self._maxx = self._screen.getmaxyx()

    def _print(self, arr):
        try:
            self._screen.addstr(self._y, 0, ''.join(arr)[:self._maxx])
            self._y += 1
        except:
            pass

    def _server_stats(self, d):
        host = self._connection.host
        out = []
        out.append("%s. v%s, %d bit" % (host, d['version'], d['mem']['bits']))
        out.append('. Conns: %d/%d' % (d['connections']['current'], d['connections']['available']))
        ratio = d['globalLock'].get('ratio')
        if ratio is None:
            ratio = float(d['globalLock']['lockTime']) / float(d['globalLock']['totalTime'])
        out.append('. Lock %%: %.2f' % round(ratio, 2))
        self._print(out)

    def _memory_stats(self, d):
        out = []
        out.append('Mem (MB): %s resident, %s virtual, %s mapped' % (d['mem']['resident'], d['mem']['virtual'], d['mem']['mapped']))
        if 'workingSet' in d:
            # value is in pages (i.e. 4k blocks), so divide it by / 256 to get MB
            out.append(', %d working set' % (round(int(d['workingSet']['pagesInMemory']) / 256.0)))
        self._print(out)

    def _repl_stats(self, d):
        repl = d.get('repl')
        if not repl:
            return

        hosts = repl.get('hosts')
        if not hosts:
            return

        out = []
        out.append('Rep (%s):' % repl['setName'])
        for host in hosts:
            out.append(' %s(%s)' % (host, 'P' if host == repl['primary'] else 'S'))
        self._print(out)

    def _op_stats(self, d):
        out = []
        out.append('Ops:')
        ops = []
        total = 0
        for op in d['opcounters']:
            val = 0
            if op in self._last_opstats:
                val = d['opcounters'][op] - self._last_opstats[op]
            self._last_opstats[op] = d['opcounters'][op]
            ops.append(' %4d %s' % (val, op))
            total += val

        ops.insert(0, ' %4d total' % total)
        out.append(','.join(ops))
        self._print(out)

    def _inprog(self, inprog):
        template = "%11s %21s %7s %1s %5s %s"
        self._print([template % ('ID', 'CLIENT', 'OP', 'A', 'LOCKW', 'NS / QUERY')])

        opsmax = self._maxy - self._y
        if len(inprog) > opsmax:
            # Leave room for '% more' line
            opsmax -= 1

        for op in inprog[:opsmax]:
            a = 'T' if op['active'] else 'F'
            lock = op.get('lockType') if op['waitingForLock'] else ''
            client = op.get('client', 'internal')
            ns_query = op['ns']
            if client == 'internal':
                ns_query += op.get('desc', '')
            query = op.get('query')
            if query:
                ns_query += " " + json.dumps(stringify_query_dict(query))[:(self._maxx - 40)]
            self._print([template % (op['opid'], client, op['op'], a, lock, ns_query)])

        if len(inprog) > opsmax:
            self._print(['( ... %d more ... )' % (len(inprog) - opsmax)])
Exemple #6
0
class Runner:
    """
    Main logic for 'mtop'. Once initialized, L{run()} keeps updating
    until ctrl-c is pressed.
    """

    def __init__(self, connection, interval):
        """
        @param connection: pymongo Connection to use.
        @param interval: Delay between updates (ms).
        """

        self._connection = connection
        self._timeout = interval / 1000
        self._mongo_ops = MongoOps(self._connection)


    def run(self):
        """
        Run loop.

        @param screen: cursus screen object.
        @return: 0 if normal exit, negative values otherwise
        """

        self._screen = Screen()
        try:
            return self._do_run()
        except KeyboardInterrupt:
            pass
        finally:
            self._screen.end()

        return 0


    def _do_run(self):
        self._screen.timeout(self._timeout)
        self._last_opstats = {}
        self._maxy, self._maxx = self._screen.getmaxyx()

        if self._maxy < 5:
            return -3

        while True:
            self._y = 0

            srvstat = self._mongo_ops.get_server_status()
            inprog = self._mongo_ops.get_inprog()
            inprog.sort(op_cmp)

            self._screen.clear()
            if srvstat:
                self._server_stats(srvstat)
                self._memory_stats(srvstat)
                self._repl_stats(srvstat)
                self._op_stats(srvstat)

            if inprog:
                self._inprog(inprog)

            time.sleep(self._timeout)

            # In the event of a resize
            self._maxy, self._maxx = self._screen.getmaxyx()


    def _print(self, arr):
        try:
            self._screen.addstr(self._y, 0, ''.join(arr)[:self._maxx])
            self._y += 1
        except:
            pass


    def _server_stats(self, d):
        host = self._connection.host
        out = []
        out.append("%s. v%s, %d bit" % (host, d['version'], d['mem']['bits']))
        out.append('. Conns: %d/%d' % (d['connections']['current'], d['connections']['available']))
        out.append('. Lock %%: %.2f' % round(float(d['globalLock']['ratio']), 2))
        self._print(out)
        

    def _memory_stats(self, d):
        self._print(['Mem: %s resident, %s virtual, %s mapped' % (d['mem']['resident'], d['mem']['virtual'], d['mem']['mapped'])])


    def _repl_stats(self, d):
        repl = d.get('repl')
        if not repl or repl['ismaster'] != 0:
            return

        sources = repl.get('sources')
        if not sources:
            return

        out = []
        out.append('Rep:')
        for source in sources:
            out.append(' %s: %ds' % (source['host'], source['lagSeconds']))
        self._print(out)


    def _op_stats(self, d):
        out = []
        out.append('Ops:')
        ops = []
        total = 0
        for op in d['opcounters']:
            val = 0
            if op in self._last_opstats:
                val = d['opcounters'][op] - self._last_opstats[op]
            self._last_opstats[op] = d['opcounters'][op]
            ops.append(' %4d %s' % (val, op))
            total += val

        ops.insert(0, ' %4d total' % total)
        out.append(','.join(ops))
        self._print(out)


    def _inprog(self, inprog):
        template = "%11s %21s %7s %1s %5s %s"
        self._print([template % ('ID', 'CLIENT', 'OP', 'A', 'LOCKW', 'NS')])

        opsmax = self._maxy - self._y
        if len(inprog) > opsmax:
            # Leave room for '% more' line
            opsmax -= 1

        for op in inprog[:opsmax]:
            a = 'T' if op['active'] else 'F'
            lock = op['lockType'] if op['waitingForLock'] else ''
            self._print([template % (op['opid'], op['client'], op['op'], a, lock, op['ns'])])

        if len(inprog) > opsmax:
            self._print(['( ... %d more ... )' % (len(inprog) - opsmax)])