redis-cli-cluster.js

#!/usr/local/bin/node
let { execSync } = require('child_process')

let args = process.argv.slice(2)

let host = ''
let port = ''
let format = 'split'

for (let i = 0; i < args.length; i++) {
    if (args[i] == '-p') {
        port = args[i + 1];
        args.splice(i--, 2);
    }
    if (args[i] == '-h') {
        host = args[i + 1];
        args.splice(i--, 2);
    }
    if (args[i] == '-f') {
        format = args[i + 1].toLowerCase();
        args.splice(i--, 2);
    }
}

let nodes = execSync(`redis-cli -h ${host} -p ${port} cluster nodes`).toString('utf8')
nodes = nodes.split('\n').map(c => (/\w+ (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}):(\d+) .*master/.exec(c) || []).splice(1)).filter(c => c.length > 0);
// console.log(nodes);

args = args.map(c => `"${c.replace(/"\\/g, "\\$0")}"`).join(" ");
console.log(args);
let rets = [];

for (const node of nodes) {
    var cmd = `redis-cli -h ${node[0]} -p ${node[1]} ${args}`;
    let ret = execSync(cmd).toString('utf8');
    if (format === 'split') {
        console.log(`\x1b[32m${node[0]}\x1b[0m:\x1b[33m${node[1]}\x1b[0m`);
        console.log(ret);
        console.log("");
    } else {
        rets.push.apply(rets, ret.split('\n').filter(c => !!c));
    }
}

if (format.endsWith("-sort") || format == 'sort') {
    rets.sort();
    format = format.substr(0, format.length - 5);
}

switch (format) {
    case 'split':
        break;
    case 'row':
        for (let i = 0; i < rets.length; i++) {
            const ret = rets[i];
            console.log((i + 1) + ")", ret);
        }
        break;
    case 'join':
    default:
        for (const ret of rets) {
            console.log(ret);
        }
        break;
}

//execSync("redis-cli ")

redis-cli-cluster.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import functools
import subprocess
import sys
import re


def run(cmd, _args) -> str: return subprocess.run([cmd] + _args, stdout=subprocess.PIPE).stdout.decode()


def each(fn, e) -> None:
    i = 0
    for v in e: fn(v, i);  i += 1


def main():
    args = sys.argv[1:]
    _format, host, port, sort = process_args(args)

    nodes = run('redis-cli', ['-h', host, '-p', port, 'cluster', 'nodes']).split('\n')
    nodes = list(map(lambda c: list(c.groups()), filter(lambda c: c, map(
        lambda c: re.match('\w+ (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}):(\d+) .*master', c), nodes))))

    rets = []
    for node in nodes:
        ret = run('redis-cli', ['-h', node[0], '-p', node[1]] + args)
        if _format == 'split':
            print("\x1b[32m{0}\x1b[0m:\x1b[33m{1}\x1b[0m".format(node[0], node[1]))
            if sort:
                print(functools.reduce(lambda a, b: a + b + '\n', filter(lambda c: c, sorted(ret.split('\n'))), ''))
            else:
                print(ret)
            print("")
        else:
            rets = rets + list(filter(lambda c: c, ret.split('\n')))

    if sort: rets.sort()

    switch = {
        'split': lambda: 0,
        'join': lambda: each(lambda v, _: print(v), rets),
        'row': lambda: each(lambda v, i: print(str(i) + ') ' + v), rets),
    }
    if _format not in switch:
        _format = 'join'
    (switch[_format] or switch['join'])()


def find_and_remove_with_next(args, v, def_value=None):
    try:
        ix = args.index(v)
        ret, args[ix:ix + 2] = args[ix + 1], []
        return ret
    except ValueError:
        return def_value


def process_args(args):
    port = find_and_remove_with_next(args, '-p')
    host = find_and_remove_with_next(args, '-h')
    _format = find_and_remove_with_next(args, '-f', 'split')

    sort = False
    if _format.endswith("-sort") or _format == 'sort': _format, sort = _format.replace('-sort', ''), True
    return _format, host, port, sort


if __name__ == '__main__':
    main()