oceanbase/script/dooba/dooba

#!/usr/bin/env python2
# -*- mode: python;coding: utf-8 -*-

# dooba ---
#
# Filename: dooba
# Description: `dooba' is a easy tools monitoring oceanbase cluster for
#               oceanbase admins. It's based on python curses library, and is a
#               powerful tool for watching oceanbase cluster status with
#               straightfoward vision.
# Created: 2013-07-23 21:05:08 (+0800)
# Version: 2.1.3
# Last-Updated: 2018-06-07T16:57:32+0800
#           By: Shi Yudi
#     Update #: 7247
#

# Change Log:
# 2018-06-06    Shi Yudi
#    Last-Updated: 2018-06-06T19:14:36+0800 #7237 (Shi Yudi)
#    1. 修复Gallery页面切租户信息不显示的问题
#
# 2018-01-16    Shi Yudi
#    Last-Updated: 2018-01-16T20:25:30+0800 #7112 (Shi Yudi)
#    1. 适配1.x分支内部表格式
#    2. 去除0.5中的ConfigHelper，1.x只能显式指定ip等信息登录
#
# 2014-11-20    Shi Yudi
#    Last-Updated: 2014-11-20T15:26:41+0800 #6946 (Shi Yudi)
#    1. show only servers in current cluster in machine stat page
#    2. a little change for machine widget
#
# 2014-05-14    Shi Yudi
#    Last-Updated: 2014-05-14T16:15:26+0800 #6913 (Shi Yudi)
#    1. skip to select cluster if only one cluster
#
# 2014-04-24    Shi Yudi
#    Last-Updated: 2014-04-24T18:57:09+0800 #6515 (Shi Yudi)
#    1. support ob 0.5 updateserver columns
#
# 2014-04-22    Shi Yudi
#    Last-Updated: 2014-04-22T19:57:35+0800 #6288 (Shi Yudi)
#    1. add column filter for ups,ms,cs page
#
# 2014-04-01    Shi Yudi
#    Last-Updated: 2014-04-01T13:41:45+0800 #5844 (Shi Yudi)
#    1. fix oceanbase 0.5 gather stats mixed by all cluster
#
# 2014-02-27    Yudi Shi
#    Last-Updated: Thu Feb 27 20:01:13 2014 (+0800) #5777 (Yudi Shi)
#    1. add fail sql exec count in gallery page
#
# 2013-12-31    Shi Yudi
#    Last-Updated: Tue Dec 31 13:10:39 2013 (+0800) #5770 (Shi Yudi)
#    1. add error msg if geometry is not enough
#    2. fix some msg output
#
# 2013-12-11    Shi Yudi
#    Last-Updated: Wed Dec 11 14:51:43 2013 (+0800) #5745 (Shi Yudi)
#    1. fix password decrypt bug (fill 8 width encoding str)
#
# 2013-10-25    Shi Yudi
#    Last-Updated: Tue Dec  3 16:01:23 2013 (+0800) #5739 (Shi Yudi)
#    1. add time to widget frame
#
# 2013-10-25    Shi Yudi
#    Last-Updated: 2013-10-25 20:28:17 (+0800) #5647 (Shi Yudi)
#    1. add http api support
#    2. add obssh to login server
#    3. using obconfig password
#
# 2013-09-04    Shi Yudi
#    Last-Updated: 2013-09-04 10:52:02 (+0800) #4786 (Shi Yudi)
#    1. add machine stat
#    2. fix many bugs
#    3. add ssh, mysql login
#    4. add delete and restore widgets
#
# 2013-08-20    Shi Yudi
#    Last-Updated: 2013-08-20 15:29:45 (+0800) #2012 (Shi Yudi)
#    1. support instant statistics monitor for ups/cs/ms
#    2. keyboard response for switch between widget
#    3. rewrite help page
#
# 2013-08-16    Shi Yudi
#    Last-Updated: 2013-08-16 16:07:32 (+0800) #1052 (Shi Yudi)
#    1. add header column widget descripe each server
#    2. add instant stat list (only for ms now)
#    3. add mergeserver header info
#
# 2013-08-14    Shi Yudi
#    Last-Updated: 2013-08-14 16:11:40 (+0800) #576 (Shi Yudi)
#    1. add MessageBox for dooba, key 'p' for test
#    2. add selective mode, TAB for swtich between widgets
#    3. add supermode option, just a husk right now
#
# 2013-08-07    Shi Yudi
#    Last-Updated: 2013-08-07 10:38:33 (+0800) #479 (Shi Yudi)
#    1. fix term evironment setting bug
#    2. fix getting appname bug
#    3. refact main method
#
# 2013-08-06    Shi Yudi
#    Last-Updated: 2013-08-06 20:47:35 (+0800) #443 (Shi Yudi)
#    1. OceanBase alive checker before running
#    2. colorfull widgets
#    3. fix some promptions
#    4. change header widget and status widget style with horizontal line
#    5. remove page border
#
# 2013-08-06    Shi Yudi
#    Last-Updated: 2013-08-06 16:46:39 (+0800) #347 (Shi Yudi)
#    1. add chunkserver, mergeserver, updateserver info widgets
#    2. fix non-lexical closures problem
#    3. dynamic helper widget promption
#    4. change some pages' index
#
# 2013-07-31    Shi Yudi
#    Last-Updated: 2013-07-31 19:11:19 (+0800) #14 (Shi Yudi)
#    1. redesign helper bar and status bar
#    2. add more pages for dooba
#    3. beauty python coding style
#
# 2013-07-23    Shi Yudi
#    1. header with app name, and other mocks.
#    2. sql rt, sql count, cs rt, ups rt are added to screen.
#
#

# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 3, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street, Fifth
# Floor, Boston, MA 02110-1301, USA.
#
#

# Code:

from collections import deque
from datetime import datetime, timedelta, date
from errno import *
from getopt import getopt, GetoptError
from locale import setlocale, LC_ALL
from os import environ, read, setsid
from pprint import pformat
from random import shuffle
from subprocess import Popen, PIPE, STDOUT, call
from telnetlib import Telnet
from threading import Thread
from time import sleep, strftime
from urllib2 import urlopen, URLError
import BaseHTTPServer
import atexit
import bz2
import curses
import curses.textpad
import itertools
import json
import math
import os
import select
import signal
import socket
import struct
import sys
import tempfile
import textwrap
import types
import traceback
import time

class Global:
    MAX_LINES = 100
    WIDGET_HEIGHT = 7
    DEFAULT_USER = 'root'
    DEFAULT_PASS = 'admin'


class Options(object):
    host = '127.0.0.1'
    port = 2828
    user = None
    password = ""
    database = "oceanbase"
    supermode = False
    interval = 1
    dataid = None
    using_ip_port = False
    env = 'unknown'
    machine_interval = 5
    degradation = False
    show_win_file = None
    daemon = False
    http = False
    daemon_action = 'start'
    # HTTP server relating
    http_port = 33244
    tenant_id = None
    tenant = None
    debug = False

    def __str__(self):
        result = {}
        for k in dir(self):
            v = getattr(self, k)
            if k.find('__') == 0:
                continue
            result[k] = v
        return pformat(result)

# auxiliary functions
class ColumnFactory(object):
    def __init__(self, svr, ip):
        self.__svr = svr
        self.__ip = ip

    def count(self, name, sname, obname, enable=False):
        DEBUG(self.count, "name,sname,obname", ",".join([str(name), str(sname), str(obname)]))
        if type(obname) == str:
            pass
        elif type(obname) == list:
            obname = [name for name in obname]
        else:
            raise Exception("unsupport type %s" % type(obname))
        DEBUG(self.count, "name,sname,obname", ",".join([str(name), str(sname), str(obname)]))
        return self.count0(name, sname, obname, enable)

    def count0(self, name, sname, obname, enable=False):
        DEBUG(self.count0, "name,sname,obname", ",".join([str(name), str(sname), str(obname)]))
        DEBUG(self.count0, "self.__svr|self.__ip", "|".join([self.__svr, self.__ip]))
        svr = self.__svr
        ip = self.__ip
        def calc_func(stat,ip=ip):
            def try_get(d, k, b):
                try:
                    if d.has_key(k):
                        return d[k]
                    else:
                        return d[b]
                except Exception as e:
                    raise e
            try:
                if type(obname) == str:
                    return try_get(stat, svr, oceanbase.get_current_tenant())[ip][obname]
                elif type(obname) == list:
                    return sum([try_get(stat, svr, oceanbase.get_current_tenant())[ip][name] for name in obname])
                else:
                    raise Exception("unsupport type %s" % type(obname))
            except KeyError as e:
#               DEBUG(calc_func, "exception", e)
                pass

        return Column(name, calc_func, 7, True, enable=enable, sname=sname)

    def time(self, name, sname, obnamet, obnamec=None, enable=False):
        if obnamec is None:
            obnamec = obnamet
        return self.time0(name, sname, obnamet, obnamec, enable)

    def time0(self, name, sname, obnamet, obnamec=None, enable=False):
        svr = self.__svr
        ip = self.__ip
        def calc_func(stat,ip=ip):
            def try_get(d, k, b):
                if d.has_key(k):
                    return d[k]
                else:
                    return d[b]
            try:
                if type(obnamec) == str:
                    total_count = try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamec]
                elif type(obnamec) == list:
                    total_count = sum([try_get(stat, svr, oceanbase.get_current_tenant())[ip][name] for name in obnamec])
                DEBUG(calc_func, "name", obnamet)
                DEBUG(calc_func, "ip", ip)
                DEBUG(calc_func, "svr", svr)
                DEBUG(calc_func, "enable", enable)
                DEBUG(calc_func, "tenant", oceanbase.get_current_tenant())
                DEBUG(calc_func, "try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamet]", try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamet])
                DEBUG(calc_func, "float(total_count)", float(total_count))
                DEBUG(calc_func, "try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamet] / 1000 / float(total_count)", try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamet] / 1000 / float(total_count or 1) )
                return try_get(stat, svr, oceanbase.get_current_tenant())[ip][obnamet] / 1000 / float(total_count or 1)
            except Exception as e:
#               DEBUG(calc_func, "exception", e)
                pass
        return Column(name, calc_func, 7, enable=enable, sname=sname)

    def cache(self, name, sname, obname):
        svr = self.__svr
        ip = self.__ip
        return Column(name, lambda stat,ip=ip: stat[svr][ip][obname+"_cache_hit"]
                      / float(stat[svr][ip][obname+"_cache_hit"] + stat[svr][ip][obname+"_cache_miss"] or 1),
                      7, enable=False, sname=sname)

def mem_str(mem_int, bit=False):
    mem_int = int(mem_int)
    if mem_int < 1024:
        return str(mem_int) + (bit and 'b' or '')
    mem_int = float(mem_int)
    mem_int /= 1024
    if mem_int < 1024:
        return "%.2fK" % mem_int + (bit and 'b' or '')
    mem_int /= 1024
    if mem_int < 1024:
        return "%.2fM" % mem_int + (bit and 'b' or '')
    mem_int /= 1024
    if mem_int < 1024:
        return "%.2fG" % mem_int + (bit and 'b' or '')
    return "UNKNOW"

def count_str(count_int, kilo=True):
    return str(count_int)

def percent_str(percent_int):
    return str(round(float(percent_int) * 100, 1)) + "%"

class Cowsay(object):
    '''Copyright 2011 Jesse Chan-Norris <jcn@pith.org>
       https://github.com/jcn/cowsay-py/blob/master/cowsay.py'''
    def __init__(self, str, length=40):
        self.__result = self.build_bubble(str, length) + self.build_cow()

    def __str__(self):
        return self.__result

    def build_cow(self):
        return """
         \   ^__^
          \  (oo)\_______
             (__)\       )\/\\
                 ||----w |
                 ||     ||
                """

    def build_bubble(self, str, length=40):
        bubble = []
        lines = self.normalize_text(str, length)
        bordersize = len(lines[0])
        bubble.append("  " + "_" * bordersize)

        for index, line in enumerate(lines):
            border = self.get_border(lines, index)
            bubble.append("%s %s %s" % (border[0], line, border[1]))
            bubble.append("  " + "-" * bordersize)

        return "\n".join(bubble)

    def normalize_text(self, str, length):
        lines  = textwrap.wrap(str, length)
        maxlen = len(max(lines, key=len))
        return [ line.ljust(maxlen) for line in lines ]

    def get_border(self, lines, index):
        if len(lines) < 2:
            return [ "<", ">" ]
        elif index == 0:
            return [ "/", "\\" ]
        elif index == len(lines) - 1:
            return [ "\\", "/" ]
        else:
            return [ "|", "|" ]


class Daemon:
        """
        A generic daemon class.

        Usage: subclass the Daemon class and override the run() method
        """
        def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
                self.stdin = stdin
                self.stdout = stdout
                self.stderr = stderr
                self.pidfile = pidfile

        def daemonize(self):
                """
                do the UNIX double-fork magic, see Stevens' "Advanced
                Programming in the UNIX Environment" for details (ISBN 0201563177)
                http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
                """
                try:
                        pid = os.fork()
                        if pid > 0:
                                # exit first parent
                                sys.exit(0)
                except OSError, e:
                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
                        sys.exit(1)

                # decouple from parent environment
                os.chdir("/")
                os.setsid()
                os.umask(0)

                # do second fork
                try:
                        pid = os.fork()
                        if pid > 0:
                                # exit from second parent
                                sys.exit(0)
                except OSError, e:
                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
                        sys.exit(1)

                # redirect standard file descriptors
                sys.stdout.flush()
                sys.stderr.flush()
                si = file(self.stdin, 'r')
                so = file(self.stdout, 'a+')
                se = file(self.stderr, 'a+', 0)
                os.dup2(si.fileno(), sys.stdin.fileno())
                os.dup2(so.fileno(), sys.stdout.fileno())
                os.dup2(se.fileno(), sys.stderr.fileno())

                # write pidfile
                atexit.register(self.delpid)
                pid = str(os.getpid())
                file(self.pidfile,'w+').write("%s\n" % pid)

        def delpid(self):
                os.remove(self.pidfile)

        def start(self):
                """
                Start the daemon
                """
                # Check for a pidfile to see if the daemon already runs
                try:
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                        pf.close()
                except IOError:
                        pid = None

                if pid:
                        message = "pidfile %s already exist. Daemon already running?\n"
                        sys.stderr.write(message % self.pidfile)
                        sys.exit(1)

                # Start the daemon
                self.daemonize()
                self.run()

        def stop(self):
                """
                Stop the daemon
                """
                # Get the pid from the pidfile
                try:
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                        pf.close()
                except IOError:
                        pid = None

                if not pid:
                        message = "pidfile %s does not exist. Daemon not running?\n"
                        sys.stderr.write(message % self.pidfile)
                        return # not an error in a restart

                # Try killing the daemon process
                try:
                        while 1:
                                os.kill(pid, signal.SIGTERM)
                                sleep(0.1)
                except OSError, err:
                        err = str(err)
                        if err.find("No such process") > 0:
                                if os.path.exists(self.pidfile):
                                        os.remove(self.pidfile)
                        else:
                                print str(err)
                                sys.exit(1)

        def restart(self):
                """
                Restart the daemon
                """
                self.stop()
                self.start()

        def run(self):
                """
                You should override this method when you subclass Daemon. It will be called after the process has been
                daemonized by start() or restart().
                """

class OceanBase(object):
    instant_key_list = [
    # mergeserver
    'ms_memory_limit', 'ms_memory_total', 'ms_memory_parser',
    'ms_memory_transformer', 'ms_memory_ps_plan', 'ms_memory_rpc_request',
    'ms_memory_sql_array', 'ms_memory_expression', 'ms_memory_row_store',
    'ms_memory_session', 'ps_count',
    # chunkserver
    'serving_version', 'old_ver_tablets_num', 'old_ver_merged_tablets_num',
    'new_ver_tablets_num', 'new_ver_tablets_num', 'memory_used_default',
    'memory_used_network', 'memory_used_thread_buffer', 'memory_used_tablet',
    'memory_used_bi_cache', 'memory_used_block_cache',
    'memory_used_bi_cache_unserving', 'memory_used_block_cache_unserving',
    'memory_used_join_cache', 'memory_used_sstable_row_cache',
    'memory_used_merge_buffer', 'memory_used_merge_split_buffer',
    # updateserver
    'memory_total', 'memory_limit', 'memtable_total', 'memtable_used',
    'total_rows', 'active_memtable_limit', 'active_memtable_total',
    'active_memtable_used', 'active_total_rows', 'frozen_memtable_limit',
    'frozen_memtable_total', 'frozen_memtable_used', 'frozen_total_rows',
    'low_prio_queued_count', 'normal_prio_queued_count', 'high_prio_queued_count',
    'hotspot_queued_count',
    # machine stat
    'load1', 'load5', 'load15', 'MemTotal', 'MemFree',
    # mock
    'timestamp'
    ]

    app_info = {'username':None, 'password':None}

    def __init__(self, dataid=None):
        self.__q = {}
        self.__stop = True
        self.__machine_stat = {}
        self.__host = Options.host
        self.__port = Options.port
        self.update_dataid(dataid)
        self.__cur_cluster_svrs = None
        self.__cur_tenant_id = 1
        self.__cur_tenant_name = 'sys'
        self.tenant = []

    def update_dataid(self, dataid):
        if dataid:
            self.app_info = ObConfigHelper().get_app_info(dataid)

    def dosql(self, sql, host=None, port=None, database=None):
        if host is None:
            host = self.__host
        if port is None:
            port = self.__port
        if host is None:
            host = Options.host
        if port is None:
            port = Options.port
        if database is None:
            database = Options.database
        username = Options.user or self.app_info['username'] or Global.DEFAULT_USER
        password = Options.password
        if password:
            mysql = "mysql --connect_timeout=5 -s -N -h%s -P%d -u%s -p%s %s" % (host, port, username, password, database)
        else:
            mysql = "mysql --connect_timeout=5 -s -N -h%s -P%d -u%s %s" % (host, port, username, database)
        cmd = "%s -e \"%s\"" % (mysql, sql)
        DEBUG(self.dosql, "", cmd)
        p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
        output = p.communicate()[0]
        err = p.wait()
        if err:
            raise Exception('popen Fail', cmd)
        return output

    def show_sql_result(self, sql, host=None, port=None, database=None):
        if host is None:
            host = self.__host
        if port is None:
            port = self.__port
        if host is None:
            host = Options.host
        if port is None:
            port = Options.port
        if database is None:
            database = Options.database
        username = Options.user or self.app_info['username'] or Global.DEFAULT_USER
        password = Options.password
        if password:
            mysql = "mysql --table --connect_timeout=5 --pager=less --column-names -h%s -P%d -u%s -p%s %s" % (host, port, username, password, database)
        else:
            mysql = "mysql --table --connect_timeout=5 --pager=less --column-names -h%s -P%d -u%s %s" % (host, port, username, database)
        cmd = "%s -e \"%s\" | less" % (mysql, sql)
        curses.endwin()
        call("clear")
        os.system(cmd)
        curses.doupdate()

    def mysql(self, host=None, port=None, database=None):
        if host is None:
            host = self.__host
        if port is None:
            port = self.__port
        if host is None:
            host = Options.host
        if port is None:
            port = Options.port
        if database is None:
            database = Options.database
        username = Options.user or self.app_info['username'] or Global.DEFAULT_USER
        password = Options.password
        if password:
            cmd = "mysql --connect_timeout=5 -h%s -P%d -u%s -p%s" % (host, port, username, password)
        else:
            cmd = "mysql --connect_timeout=5 -h%s -P%d -u%s" % (host, port, username)
        DEBUG(self.mysql, "mysql", cmd)
        environ['MYSQL_PS1'] = "(\u@\h) [%s]> " % self.app
        call('clear')
        try:
            call(cmd, shell=True)
        except KeyboardInterrupt:
            pass
        call('clear')

    def ssh(self, host):
        cmd = "ssh -o StrictHostKeyChecking=no %s" % host
        call('clear')
        try:
            call(cmd, shell=True)
        except KeyboardInterrupt:
            pass
        call('clear')

    def test_alive(self, fatal=True, do_false=None, do_true=None, host=None, port=None):
        if host is None:
            host = Options.host
        if port is None:
            port = Options.port
        try:
            oceanbase.dosql('select 1', host=host, port=port)
            if do_true is not None:
                do_true("Check oceanbase alive successfully! [%s:%d]" % (host, port))
        except Exception:
            if do_false is not None:
                do_false("Can't connect oceanbase, plz check options!\n"
                         "Options: [IP:%s] [PORT:%d] [USER:%s] [PASS:%s]"
                         % (host, port, Options.user, Options.password))
            if fatal:
                exit(1)
            else:
                return False
        return True

    def __check_schema(self):
        sql = """desc gv\\$sysstat"""
        res = self.dosql(sql)
        if "CON_ID" in res.split("\n")[0]:
            return """ select current_time(), con_id, svr_ip, svr_port, name, value from gv\$sysstat where con_id = %s"""
        else:
            return """ select current_time(), tenant_id, svr_ip, svr_port, stat_name, value from gv\$sysstat where tenant_id = %s"""

    def __get_all_stat(self):
        sql = self.__check_schema() % (str(self.get_current_tenant()))
        res = self.dosql(sql)
        r = dict()
        time = ''
        if not self.__using_server_time():
            time = str(datetime.now())
        for one in res.split("\n")[:-1]:
            a = one.split("\t")
            if self.__using_server_time():
                time = a[0]
            now = datetime.strptime(time, '%Y-%m-%d %H:%M:%S.%f')
            tnt = a[1]
            ip = a[2]
            port = a[3]
            name = a[4]
            value = int(a[5])
            ipport = ip + ":" + port
            a = [time, tnt, ip, port, name, value]
            DEBUG(self.__get_all_stat, "stuffs", a)
            if tnt not in r:
                r[tnt] = dict()
            if ipport not in r[tnt]:
                r[tnt][ipport] = dict()
            r[tnt][ipport][name] = value
            r['time'] = now
            r['timestamp'] = now
        return r

    def sub_stat(self, now, prev):
        r = self.__sub_stat(now, prev)
        return r

    def __sub_stat(self, now, prev):
        r = {}
        for k in now.keys():
            if k in self.instant_key_list:
                r[k] = now[k]
            elif type(now[k]) == dict:
                r.update({k: self.__sub_stat(now[k], prev[k])})
            elif type(now[k]) == int:
                r[k] = now[k] - prev[k]
            elif type(now[k]) == float:
                r[k] = now[k] - prev[k]
            elif type(now[k]) == type(datetime.min):
                r[k] = now[k] - prev[k]
            else:
                #print type(now[k])
                pass
        return r

    def __update_oceanbase_stat_runner(self):
        q = self.__q
        prev = self.__get_all_stat()
        while not self.__stop:
            sleep(Options.interval)
            if self.__stop:
                break
            try:
                cur = self.__get_all_stat()
            except Exception:
                continue
            if str(oceanbase.get_current_tenant()) not in cur:
                # tid has changed before result returned, ignore it.
                prev = self.__get_all_stat()
                continue
            try:
                q.append(self.__sub_stat(cur, prev))
                if (len(q) > Global.MAX_LINES):
                    q.popleft()
            except KeyError:
                pass
            prev = cur

    def __do_ssh(self, host, cmd):
        BUFFER_SIZE = 1 << 16
        ssh = Popen(['ssh', '-o', 'PreferredAuthentications=publickey',
                     '-o', 'StrictHostKeyChecking=no', host, cmd],
                    stdout=PIPE, stderr=PIPE, preexec_fn=setsid, shell=False)
        output = ssh.communicate()[0]
        err = ssh.wait()
        if err:
            raise Exception('popen Fail', "%s: %s" % (host, cmd))
        return output

    def __get_machine_stat(self, ip):
        cmd = ("cat <(date +%s%N) <(cat /proc/stat | head -1 | cut -d' ' -f 3-9) "
               "/proc/loadavg  <(cat /proc/meminfo) <(echo END_MEM) "
               "<(cat /proc/net/dev | sed -n 3~1p) <(echo END_NET) "
               "<(cat /proc/diskstats | grep '  8  ') <(echo END_DISK)")
        try:
            output = self.__do_ssh(ip, cmd)
        except Exception:
            return {}

        lines = output.split('\n')

        res = {}
        res['time'] = float(lines[0]) / 1000   # ms
        lines = lines[1:]

        cpuinfo = lines[0]
        columns = cpuinfo.split(" ")
        res['user'] = int(columns[0])
        res['nice'] = int(columns[1])
        res['sys'] = int(columns[2])
        res['idle'] = int(columns[3])
        res['iowait'] = int(columns[4])
        res['irq'] = int(columns[5])
        res['softirq'] = int(columns[6])
        res['total'] = 0
        for c in columns:
            res['total'] += int(c)
        lines = lines[1:]

        loadavg = lines[0]
        columns = loadavg.split(" ")
        res['load1'] = columns[0]
        res['load5'] = columns[1]
        res['load15'] = columns[2]
        lines = lines[1:]

        # mem
        for line in lines:
            if 'END_MEM' == line:
                break
            kv = line.split()
            k = kv[0][:-1]
            v = kv[1]
            res[k] = int(v) * 1024
        idx = lines.index('END_MEM')
        lines = lines[idx + 1:]

        # net
        res['net'] = {}
        for line in lines:
            if 'END_NET' == line:
                break
            colon = line.find(':')
            assert colon > 0, line
            name = line[:colon].strip()
            res['net'][name] = {}
            fields = line[colon+1:].strip().split()
            res['net'][name]['bytes_recv'] = int(fields[0])
            res['net'][name]['packets_recv'] = int(fields[1])
            res['net'][name]['errin'] = int(fields[2])
            res['net'][name]['dropin'] = int(fields[3])
            res['net'][name]['bytes_sent'] = int(fields[8])
            res['net'][name]['packets_sent'] = int(fields[9])
            res['net'][name]['errout'] = int(fields[10])
            res['net'][name]['dropout'] = int(fields[11])
        idx = lines.index('END_NET')
        lines = lines[idx + 1:]

        res['disk'] = {}
        SECTOR_SIZE = 512
        for line in lines:
            # http://www.mjmwired.net/kernel/Documentation/iostats.txt
            if 'END_DISK' == line:
                break
            _, _, name, reads, _, rbytes, rtime, writes, _, wbytes, wtime = line.split()[:11]
            res['disk'][name] = {}
            res['disk'][name]['rbytes'] = int(rbytes) * SECTOR_SIZE
            res['disk'][name]['wbytes'] = int(wbytes) * SECTOR_SIZE
            res['disk'][name]['reads'] = int(reads)
            res['disk'][name]['writes'] = int(writes)
            res['disk'][name]['rtime'] = int(rtime)
            res['disk'][name]['wtime'] = int(wtime)
        return res
        idx = lines.index('END_DISK')
        lines = lines[idx + 1:]

    def __update_server_stat_runner(self):
        prev = {}
        for ip in self.ip_list:
            prev[ip] = self.__get_machine_stat(ip)
        while not self.__stop:
            sleep(Options.machine_interval)
            shuffle(self.ip_list)
            for ip in self.ip_list:
                if self.__stop:
                    break
                cur = self.__get_machine_stat(ip)
                try:
                    result = self.__sub_stat(cur, prev[ip])
                    self.__machine_stat.update({ip: result})
                except KeyError:
                    pass
                prev[ip] = cur

    def __update_version(self):
        self.version = "Unknown"
        res = self.dosql("show variables like 'version_comment'")
        for one in res.split("\n")[:-1]:
            a = one.split("\t")
            self.version = a[1]
        self.app = oceanbase.dosql("select value from __all_virtual_sys_parameter_stat where name='cluster' limit 1")[:-1]

    def __using_server_time(self):
        if self.version.find('0.4.1') >= 0:
            return False
        elif self.version.find('0.4.2') >= 0:
            return True
        return False

    def start(self):
        self.__stop = False
        self.__q = deque([])
        self.__th = Thread(target=self.__update_oceanbase_stat_runner, args=())
        self.__th.daemon = True
        self.__th.start()
        if Options.env == 'online':
            self.__update_ip_list()
            self.__machine_stat = {}
            self.__svr_th = Thread(target=self.__update_server_stat_runner, args=())
            self.__svr_th.daemon = True
            self.__svr_th.start()

    def dump_queue(self):
        print self.__q

    def now(self):
        return self.__q[-1]

    def stat_count(self):
        return len(self.__q)

    def latest(self, num=1):
        return list(self.__q)[-num:]

    def machine_stat(self):
        return self.__machine_stat

    def update_tenant_info(self):
        DEBUG(self.update_tenant_info, "update_tenant_info", "start update_tenant_info")
        class Tenant:
            def __init__(self, tid, name, zone_list, selected):
                self.tenant_id = tid
                self.tenant_name = name
                self.zone_list = zone_list
                self.selected = selected
                self.svr_list = {"observer":[]}
        res = self.dosql("select tenant_id, tenant_name, zone_list from __all_tenant")
        self.tenant = []
        flg = True
        for line in res.split("\n")[0:-1]:
            tnt = line.split("\t")
            self.tenant.append(Tenant(tnt[0], tnt[1], tnt[2], flg))
            flg = False
        DEBUG(self.update_tenant_info, "self.tenant", self.tenant)

        svrs = self.dosql("select svr_ip, svr_port, id, zone, inner_port, with_rootserver, status from __all_server")
        for line in svrs.rstrip("\n").split("\n"):
            svr = line.split("\t")
            for tnt in self.tenant:
                tnt.svr_list["observer"].append({"ip":svr[0], "port":svr[1], "role":svr[5]})

        self.__update_version()
        #self.__update_ip_list()
        self.__update_cur_cluster_info()
        self.__update_ip_list()
        self.__update_sample()

    def check_lms(self, say):
        if Options.dataid is not None:
            lms_list = self.app_info['lms_list']
            if not lms_list or len(lms_list) <= 0:
                say('Get lms list fail, plz check'
                    + ' [ dataid = %s, lms_list = %s ]' % (Options.dataid, lms_list))
            else:
                for lms in lms_list:
                    say('checking lms [%s:%s]' % lms)
                    if oceanbase.test_alive(host=lms[0], port=lms[1], fatal=False,
                                            do_false=say, do_true=say):
                        self.__host = lms[0]
                        self.__port = lms[1]
                        #oceanbase.update_cluster_info()
                        oceanbase.update_tenant_info()
                        return True
        return False

    def __update_sample(self):
        self.sample = self.__get_all_stat()
        self.sample['time'] = timedelta()

    def __update_ip_list(self):
        ip_list = []
        ip_map = {}
        for clu in self.tenant:
            svr_list = clu.svr_list
            for name in ["observer"]:
                ip_list += [svr["ip"] for svr in svr_list[name]]
                for ip in [svr["ip"] for svr in svr_list[name]]:
                    if ip in ip_map:
                        ip_map[ip].append(name)
                    else:
                        ip_map[ip] = [name]
        self.ip_list = list(set(ip_list))
        self.ip_map = ip_map

#   def __update_ip_list(self):
#       ip_list = []
#       ip_map = {}
#       for clu in self.cluster:
#           svr_list = clu.svr_list
#           for name in ('chunkserver', 'mergeserver', 'updateserver', 'rootserver'):
#               ip_list += [svr['ip'] for svr in svr_list[name]]
#               for ip in [svr['ip'] for svr in svr_list[name]]:
#                   if ip in ip_map:
#                       ip_map[ip].append(name)
#                   else:
#                       ip_map[ip] = [name]
#       self.ip_list = list(set(ip_list))
#       self.ip_map = ip_map

    def __update_cur_cluster_info(self):
        for tnt in self.tenant:
            self.__cur_tenant_id = tnt.tenant_id
            self.__cur_cluster_svrs = tnt.svr_list
            return self.__cur_cluster_svrs

#   def __update_cur_cluster_info(self):
#       ip = self.__host
#       port = self.__port
#       for clu in self.cluster:
#           for ms in clu.svr_list['mergeserver']:
#               if ms['ip'] == ip and ms['port'] == port:
#                   if Options.dataid:
#                       self.__host, self.__port = clu.vip, clu.port
#                   self.__cur_cluster_svrs = clu.svr_list
#                   self.__cur_cluster_id = clu.id
#                   return self.__cur_cluster_svrs
#           if clu.vip == ip and clu.port == port:
#               if Options.dataid:
#                   self.__host, self.__port = clu.vip, clu.port
#               self.__cur_cluster_svrs = clu.svr_list
#               self.__cur_cluster_id = clu.id
#               return self.__cur_cluster_svrs
#       return {}

    def update_lms(self):
        svrs = oceanbase.dosql("select svr_ip, svr_port from __all_server where with_rootserver = 1 limit 1")
        for line in svrs.rstrip("\n").split("\n"):
            svr = line.split("\t")
            ip = svr[0]
            try:
                port = int(svr[1])
                self.__host = svr[0]
                self.__port = svr[1]
            except ValueError:
                return

#   def update_lms(self):
#       svrs = oceanbase.dosql("select svr_ip,svr_port from (select * from __all_server_stat) t where svr_type='updateserver' limit 1")
#       for line in svrs.rstrip("\n").split("\n"):
#           svr = line.split("\t")
#           ip = svr[0]
#           try:
#               port = int(svr[1])
#           except ValueError:            # no lms
#               return
#       for clu in self.cluster:
#           for ups in clu.svr_list['updateserver']:
#               if ups['ip'] == ip and ups['port'] == port:
#                   self.__host = clu.vip
#                   self.__port = clu.port
#                   return

    def __set_current_tenant(self, tname, tid):
        self.__cur_tenant_name = tname
        self.__cur_tenant_id = tid

    def get_current_tenant(self):
        return self.__cur_tenant_id

    def get_current_tenant_name(self):
        return self.__cur_tenant_name

    def get_tenant_svr(self, tid=None):
        for tnt in self.tenant:
            DEBUG(self.get_tenant_svr, "cur_tenant_id.selected", str(tnt.tenant_id) + "|" + str(tnt.selected))
            if True == tnt.selected:
                return tnt.svr_list

    def find_svr_list(self):
        if not self.__cur_cluster_svrs:
            self.__update_cur_cluster_info()
        return self.__cur_cluster_svrs

    def stop(self):
        self.__stop = True

    def switch_tenant(self, tid):
        tname = "sys"
        for tnt in self.tenant:
            if str(tid) == str(tnt.tenant_id) or tid == tnt.tenant_name:
                tname = tnt.tenant_name
                tid = tnt.tenant_id
                tnt.selected = True
                self.__q.clear()
            else:
                tnt.selected = False
        DEBUG(self.switch_tenant, "self.tenant.selected", [" ".join([tnt.tenant_id, str(tnt.selected)]) for tnt in self.tenant])
        self.__update_cur_cluster_info()
        self.__update_sample()
        self.__set_current_tenant(tname, tid)


class Page(object):
    def __init__(self, parent, layout, y, x, height, width):
        self.__parent = parent
        self.__layout = layout
        self.__widgets = []
        self.__win = parent.derwin(height, width, y, x)
        self.__y = y
        self.__x = x
        self.__height = height
        self.__width = width
        self.border()
        self.__win.nodelay(1)
        self.__win.timeout(0)
        self.__win.keypad(1)
        self.move(y, x)
        self.resize(height, width)
        self.__cur_select = 0
        self.__shown_widget_num = 0

    def add_widget(self, widget):
        if 0 == len(self.__widgets):
            widget.select(True)
        self.__widgets.append(widget)
        self.__rearrange()

    def update_widgets(self):
        pass

    def __rearrange(self):
        undeleted_widgets = filter(lambda w: False == w.delete(), self.__widgets)
        self.__layout.rearrange(0, 0, self.__height, self.__width, undeleted_widgets)

    def rearrange(self):
        self.__rearrange()

    def update(self):
        self.update_widgets()

    def clear_widgets(self):
        self.__widgets = []

    def resize(self, height, width):
        self.__height = height
        self.__width = width
        self.__win.resize(height, width)
        self.__rearrange()

    def move(self, y, x):
        self.__x = x
        self.__y = y
        self.__win.mvderwin(y, x)
        self.__rearrange()

    def __reset_widgets(self):
        if len(self.__widgets) <= 0:
            return
        shown_widgets = self.shown_widgets()
        map(lambda w: w.select(False), self.__widgets)
        map(lambda w: w.delete(False), self.__widgets)
        self.__cur_select = 0
        self.__widgets[self.__cur_select].select(True)
        self.__rearrange()

    def __delete_current_widget(self):
        shown_widgets = self.shown_widgets()
        if len(shown_widgets) <= 0:
            return
        shown_widgets[self.__cur_select].select(False)
        shown_widgets[self.__cur_select].delete(True)
        self.__cur_select -= 1
        self.select_next()
        self.__rearrange()

    def border(self):
        pass

    def process_key(self, ch):
        if ch == ord('d'):
            self.__delete_current_widget()
        elif ch == ord('R'):
            self.__reset_widgets()
        elif ch == ord('m'):
            curses.endwin()
            oceanbase.mysql()
            curses.doupdate()
        elif ch == ord('j'):
            curses.endwin()
            w = self.selected_widget()
            oceanbase.ssh(w.host())
            curses.doupdate()

    def redraw(self):
        self.erase()
        self.__layout.redraw(self.shown_widgets())

    def getch(self):
        return self.__win.getch()

    def erase(self):
        self.__win.erase()

    def win(self):
        return self.__win

    def title(self):
        return 'Untitled'

    def select_next(self):
        shown_widgets = self.shown_widgets()
        if len(shown_widgets) <= 0:
            return
        shown_widgets[self.__cur_select].select(False)
        self.__cur_select = (self.__cur_select + 1) % len(shown_widgets)
        shown_widgets[self.__cur_select].select(True)

    def parent(self):
        return self.__parent

    def shown_widgets(self):
        '''Actually shown widgets that is all widgets except for
        1. deleted widgets and,
        2. couldn\'t display widgets as no space for them.
        '''
        return filter(lambda w: w.show() and False == w.delete(), self.__widgets)

    def valid_widgets(self):
        '''All widgets excpet for the deleted widgets.'''
        return filter(lambda w: False == w.delete(), self.__widgets)

    def all_widgets(self):
        return self.__widgets

    def selected_widget(self):
        '''
        may has no selected widget
        '''
        if len(self.shown_widgets()) > self.__cur_select:
            return self.shown_widgets()[self.__cur_select]
        return None

    def select_columns(self):
        if len(self.all_widgets()) > 0:
            all_widgets = [hc_widget.column_widget() for hc_widget in self.all_widgets()]
            columns = all_widgets[0].valid_columns()
            columns_ret = ColumnCheckBox('Select Columns', columns, self.__parent).run()
            for widget in all_widgets:
                for idx in range(0, len(columns)):
                    widget.valid_columns()[idx].enable(columns[idx].enable(enable=True))
                widget.update()
            [hc_widget.resize() for hc_widget in self.all_widgets()]
            self.rearrange()


class Layout(object):
    def __init__(self):
        pass

    def redraw(self, widgets):
        for widget in widgets:
            try:
                if widget.show():
                    widget.redraw()
            except Exception:
                pass

    def __calc_widget_height(self, height, width, widgets):
        max_min_height = max([ widget.min_height() for widget in widgets ])
        for widget in widgets:
            widget.min_height(max_min_height)

        wwidths = [ widget.min_width() for widget in widgets ]
        cur_width = 0
        nline = 1
        for wwidth in wwidths:
            if cur_width + wwidth <= width:
                cur_width += wwidth
            else:
                cur_width = wwidth
                nline += 1
        widget_height = height / nline
        return max(widget_height, max_min_height)

    def rearrange(self, y, x, height, width, widgets):
        if height <= 0 or width <= 0 or len(widgets) <= 0:
            return 0
        widget_height = self.__calc_widget_height(height, width, widgets)

        for widget in widgets:
            widget.show(False)
        cur_y = 0
        cur_x = 0
        for index,widget in enumerate(widgets):
            if cur_x + widget.min_width() > width:
                cur_y += widget_height
                cur_x = 0
            try:
                widget.move(0, 0)
                widget.resize(widget_height, widget.min_width())
                widget.move(cur_y + y, cur_x + x)
                widget.show(True)
            except curses.error:
                return index
            cur_x += widget.min_width()
        return len(widgets)


class Widget(object):
    def __init__(self, min_height, min_width, parent, use_win=False):
        if use_win:
            self.__win = parent
        else:
            self.__win = parent.derwin(min_height, min_width, 0, 0)
        self.__min_height = min_height
        self.__min_width = min_width
        self.__height, self.__width = self.__win.getmaxyx()
        self.__y, self.__x = self.__win.getmaxyx()
        self.__select = False
        self.__show = False
        self.__deleted = False

    def resize(self, height, width):
        self.__height = height
        self.__width = width
        maxh, maxw = self.__win.getmaxyx()
        if (width > maxw):
            MessageBox(self.__win, "TERM is too small!").run(anykey=True)
            exit(1)
        self.__win.resize(height, width)

    def move(self, y, x):
        self.__win.mvderwin(y, x)
        self.__y = y
        self.__x = x

    def mvwin(self, y, x):
        self.__win.mvwin(y, x)
        self.__y = y
        self.__x = x

    def min_height(self, height=None):
        if height:
            self.__min_height = height
        return self.__min_height

    def min_width(self, width=None):
        if width:
            self.__min_width = width
        return self.__min_width

    def geometry(self):
        return self.__y, self.__x, self.__height, self.__width

    def height(self):
        return self.__height

    def width(self):
        return self.__width

    def redraw(self):
        pass

    def refresh(self):
        self.__win.refresh()

    def erase(self):
        self.__win.erase()

    def win(self):
        return self.__win

    def select(self, select = None):
        if select is not None:
            self.__select = select
        return self.__select

    def win(self):
        return self.__win

    def show(self, show=None):
        if show is not None:
            self.__show = show
        return self.__show

    def update(self):
        pass

    def delete(self, delete=None):
        if delete is not None:
            self.__deleted = delete
        return self.__deleted


class Column(object):
    def __init__(self, name, filter, width, duration=False, enable=True, sname=None):
        self.__name = name
        self.__filter = filter
        self.__width = width
        self.__duration = duration
        self.__enable = enable
        self.__sname = sname or name
        self.__valid = True
        DEBUG(self.__init__, "self.__name, self.__sname", ",".join([self.__name, self.__sname]))

    def __str__(self):
        return self.name() + " (" + self.sname() + ")"

    def __repr__(self):
        return self.name()

    def __eq__(self, obj):
        return isinstance(obj, Column) and self.name() == obj.name()

    def name(self):
        return self.__name

    def sname(self):
        return self.__sname

    def header(self):
        return self.__sname.center(self.__width).upper()

    def value(self, stat):
        def seconds(td):
            return float(td.microseconds +
                         (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6;

        d = self.__filter(stat)
        if type(d) == type(0.0):
            div = (seconds(stat["timestamp"]) or 1.0) if self.__duration else 1.0
            v = d / div
            if (v > 100):
                v = int(v)
                return str(v).center(self.__width)[:self.__width]
            return ("%.2f" % v).center(self.__width)[:self.__width]
        elif type(d) == type(0):
            div = (seconds(stat['time']) or 1.0) if self.__duration else 1.0
            v = int(d / div)
            if (self.__sname == 'ni' or self.__sname == 'no'):
                return mem_str(v).center(self.__width)[:self.__width]
            return str(v).center(self.__width)[:self.__width]
        elif type(d) == type(''):
            return d.center(self.__width)[:self.__width]

    def enable(self, enable=None):
        if enable is not None:
            self.__enable = enable
        return self.__enable

    def valid(self, valid=None):
        if valid is not None:
            self.__valid = valid
        return self.__valid

class MachineStatWidget(Widget):
    def __init__(self, name, parent, border=True):
        self.__name = name
        self.__border = border
        width = 48
        Widget.__init__(self, 20, width, parent)

    def host(self):
        return self.__name.split(':')[0]

    def type_str(self):
        return self.__name.split(':')[1]

    def redraw(self):
        if self.__border:
            if self.select():
                self.win().attron(curses.color_pair(1) | curses.A_BOLD)
                self.win().box()
                self.win().attroff(curses.color_pair(1) | curses.A_BOLD)
            else:
                self.win().box()
            self.win().addstr(0, 2, " " + self.__name + " ", curses.color_pair(3))

        try:
            stat = oceanbase.machine_stat()[self.host()]
        except KeyError:
            return

        if self.__border:
            # cpu info
            self.win().addstr(1, 2, "%-7s%4s%%" % ("CPU", "100"), curses.color_pair(7) | curses.A_BOLD)
            # self.win().attron(curses.color_pair(8))
            self.win().addstr(1, 17, "%-7s%4.1f%%" % ("nice:", float(stat['nice']) / stat['total'] * 100))
            self.win().addstr(2, 2, "%-7s%4.1f%%" % ("user:", float(stat['user']) / stat['total'] * 100))
            self.win().addstr(2, 17, "%-7s%4.1f%%" % ("iowait:", float(stat['iowait']) / stat['total'] * 100))
            self.win().addstr(3, 2, "%-7s%4.1f%%" % ("sys:", float(stat['sys']) / stat['total'] * 100))
            self.win().addstr(3, 17, "%-7s%4.1f%%" % ("irq:", float(stat['irq']) / stat['total'] * 100))
            self.win().addstr(4, 2, "%-7s%4.1f%%" % ("idle:", float(stat['idle']) / stat['total'] * 100))
            self.win().addstr(4, 17, "%-7s%4.1f%%" % ("sirq:", float(stat['softirq']) / stat['total'] * 100))
            # self.win().attroff(curses.color_pair(8))

            # load
            self.win().addstr(1, 32, "%-7s%6s" % ("Load", "x-core"), curses.color_pair(7) | curses.A_BOLD)
            # self.win().attron(curses.color_pair(8))
            self.win().addstr(2, 32, "%-7s%6s" % ("1 min:", stat['load1']))
            self.win().addstr(3, 32, "%-7s%6s" % ("5 min:", stat['load5']))
            self.win().addstr(4, 32, "%-7s%6s" % ("15 min:", stat['load15']))
            # self.win().attroff(curses.color_pair(8))

            # mem info
            self.win().addstr(6, 2, "%-6s%7s" % ("Mem", mem_str(stat['MemTotal'])), curses.color_pair(7) | curses.A_BOLD)
            self.win().addstr(7, 2, "%-6s%7s" % ("used:", mem_str(stat['MemTotal'] - stat['MemFree'])))
            self.win().addstr(8, 2, "%-6s%7s" % ("free:", mem_str(stat['MemFree'])))

            # net info
            self.win().addstr(6, 17, "%-9s%9s%9s" % ("Network", 'Rx/s', 'Tx/s'), curses.color_pair(7) | curses.A_BOLD)
            for idx,item in enumerate(stat['net'].items()):
                if idx > 5:
                    break
                self.win().addstr(7 + idx, 17, "%-9s%9s%9s" %
                                  (item[0],
                                   mem_str(item[1]['bytes_recv'] * pow(10, 6) / float(stat['time']), bit=True),
                                   mem_str(item[1]['bytes_sent'] * pow(10, 6) / float(stat['time']), bit=True)))

            # disk io info
            self.win().addstr(14, 2, "%-5s%6s%9s" % ("Disk I/O", 'In/s', 'Out/s'), curses.color_pair(7) | curses.A_BOLD)
            idx = 15
            for item in stat['disk'].items():
                if idx >= self.height() - 1:
                    break
                if item[1]['rbytes'] <= 0 and item[1]['wbytes'] <= 0:
                    continue
                self.win().addstr(idx, 2, "%-5s%9s%9s" %
                                  (item[0],
                                   mem_str(item[1]['rbytes'] * pow(10, 6) / float(stat['time'])),
                                   mem_str(item[1]['wbytes'] * pow(10, 6) / float(stat['time']))))
                idx += 1


class ColumnWidget(Widget):
    def __init__(self, name, columns, parent, border=True):
        self.__check_column_valid(columns)
        self.__name = name
        self.__columns = columns
        self.__border = border
        enabled_columns = filter(lambda c: c.enable(), self.valid_columns())
        width = len(" ".join([c.header() for c in enabled_columns])) + 2 # 2 padding
        width = max(width, 18)
        if border:
            width += 2
        Widget.__init__(self, Global.WIDGET_HEIGHT, width, parent)

    def __check_column_valid(self, columns):
        for c in columns:
            try:
                c.value(oceanbase.sample)
            except KeyError:
                c.valid(False)

    def valid_columns(self):
        return filter(lambda c: c.valid(), self.__columns)

    def update(self):
        enabled_columns = filter(lambda c: c.enable(), self.valid_columns())
        width = len(" ".join([c.header() for c in enabled_columns])) + 2 # 2 border + 2 padding
        if self.__border:
            width += 2
        self.min_width(width)

    def redraw(self):
        def stat_count():
            return oceanbase.stat_count()
        def latest(num):
            return oceanbase.latest(num)
        enabled_columns = filter(lambda c: c.enable(), self.valid_columns())
        if self.__border:
            if self.select():
                self.win().attron(curses.color_pair(1) | curses.A_BOLD)
                self.win().box()
                self.win().attroff(curses.color_pair(1) | curses.A_BOLD)
            else:
                self.win().box()
            if self.__name:
                self.win().addstr(0, 2, " " + self.__name + " ", curses.color_pair(3))
            print_lines = min(stat_count(), self.height() - 3)
            self.win().addstr(1, 1, " " + " ".join([ c.header() for c in enabled_columns ]) + " ", curses.color_pair(2))
            border_offset = 1
        else:
            print_lines = min(stat_count(), self.height() - 1)
            self.win().addstr(0, 0, " " + " ".join([ c.header() for c in enabled_columns ]) + " ", curses.color_pair(2))
            border_offset = 0
        latest = latest(print_lines)
        li = []
        for i in range(0, len(latest)):
            item = []
            for c in enabled_columns:
                item.append(str(c.value(latest[i])))
            li.append(" " + " ".join(item))
            for i in range(0, len(li)):
                self.win().addstr(i + 1 + border_offset, border_offset, li[i])


class HeaderColumnWidget(Widget):
    def __init__(self, name, columns, parent, padding=0, get_header=None):
        self.__name = name
        self.__padding = padding
        self.__get_header = get_header
        Widget.__init__(self, Global.WIDGET_HEIGHT, 0, parent)
        self.__column_widget = ColumnWidget(None, columns, self.win(), border=False)
        self.min_width(self.__column_widget.min_width() + 2)
        self.resize(self.min_height(), self.min_width())

    def redraw(self):
        if self.select():
            self.win().attron(curses.color_pair(1))
            self.win().box()
            self.win().attroff(curses.color_pair(1))
        else:
            self.win().box()

        nline = 1
        if self.__get_header and oceanbase.stat_count() > 0:
            header = self.__get_header(oceanbase.now())
            string = ""
            for item in header.items():
                item_str = ": ".join([item[0], str(item[1])])
                if (len(string) + len(item_str) + 2 > self.min_width() - 2):
                    string = string[2:]
                    self.win().addstr(nline, 1, string.center(self.min_width() - 2))
                    string = ""
                    nline += 1
                string += "  " + item_str
            if string:
                string = string[2:]
                self.win().addstr(nline, 1, string.center(self.min_width() - 2))
                self.__set_padding(nline)
            else:                         # fix ob 0.4.1 wired bug
                self.__set_padding(0)
        self.__column_widget.redraw()
        if self.__name:
            self.win().addstr(0, 2, " " + self.__name + " ", curses.color_pair(3))
        time = strftime(" %Y-%m-%d %T ")
        self.win().addstr(0, self.width() - len(time) - 2, time, curses.color_pair(3))

    def resize(self, height=None, width=None):
        if height is not None and width is not None:
            Widget.resize(self, height, width)
            maxy, maxx = self.win().getmaxyx()
            self.__column_widget.resize(maxy - self.__padding - 2, maxx - 2)
        if height is None:
            height = self.__column_widget.min_height() + self.__padding + 2
            self.resize(height, width)
        if width is None:
            width = self.__column_widget.min_width() + 2
            self.min_width(width)
            self.resize(height, width)

    def move(self, y, x):
        self.win().mvderwin(y, x)
        self.__column_widget.win().mvderwin(self.__padding + 1, 1)

    def __set_padding(self, padding):
        self.min_height(padding + 2 + 2)
        maxy, maxx = self.win().getmaxyx()
        self.__padding = padding
        self.__column_widget.move(0, 0)
        self.__column_widget.resize(maxy - self.__padding - 2, maxx - 2)
        self.__column_widget.move(self.__padding + 1, 1)

    def update(self):
        self.__column_widget.update()

    def host(self):
        return self.__name.split(":")[0]

    def sql_port(self):
        return self.__name.split(":")[1]

    def column_widget(self):
        return self.__column_widget

class StatusWidget(Widget):
    def __init__(self, parent):
        self.__parent = parent
        maxy, maxx = parent.getmaxyx()
        Widget.__init__(self, 2, maxx, parent)

        self.resize(2, maxx)
        self.move(maxy - 2, 0)
        self.win().bkgd(curses.color_pair(1))

    def redraw(self):
        now = strftime("%Y-%m-%d %T")
        maxy, maxx = self.win().getmaxyx()
        tps = self.__get_tps()
        qps = self.__get_qps()
        svr_list = oceanbase.find_svr_list()["observer"][0]
        statstr = "HOST: %s:%d " % (Options.host, Options.port)
        statstr += "%s<%s> TPS: %-6d QPS: %-6d " % (oceanbase.app, oceanbase.get_current_tenant_name(), tps, qps)
        statstr += "SERVERS: %d" % (len(svr_list))
        try:
            self.win().addstr(1, maxx - len(now) - 2, now)
            self.win().addstr(1, 2, statstr)
            self.win().hline(0, 0, curses.ACS_HLINE, 1024)
        except curses.error:
            pass

    def __seconds(self, td):
        return float(td.microseconds +
                     (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6;

    def __get_tps(self):
        tid = str(oceanbase.get_current_tenant())
        if oceanbase.stat_count() > 1:
            last = oceanbase.now()
            insert = sum([item["sql insert count"]
                            for item in last[tid].values()])
            replace = sum([item["sql replace count"]
                            for item in last[tid].values()])
            delete = sum([item["sql delete count"]
                            for item in last[tid].values()])
            update = sum([item["sql update count"]
                            for item in last[tid].values()])
            tps = float(insert + replace + delete + update) / self.__seconds(last['time'])
            return int(tps)
        else:
            return 0

    def __get_qps(self):
        tid = str(oceanbase.get_current_tenant())
        if oceanbase.stat_count() > 1:
            last = oceanbase.now()
            total = float(sum([item["sql select count"]
                               for item in last[tid].values()]))
            qps = total / self.__seconds(last['time'])
            return int(qps)
        else:
            return 0


class HeaderWidget(Widget):
    def __init__(self, parent):
        maxy, maxx = parent.getmaxyx()
        Widget.__init__(self, 2, maxx, parent)
        self.__page = None
        self.win().bkgd(curses.color_pair(1))

    def redraw(self):
        self.erase()
        if self.__page is None:
            try:
                self.win().addstr(0, 2, '1:Help 2:Gallery 3:SQL(ObServer)', curses.A_BOLD)
                self.win().hline(1, 0, curses.ACS_HLINE, 1024, curses.A_BOLD)
            except curses.error:
                pass
        else:
            maxy, maxx = self.win().getmaxyx()
            shown_num = len(self.__page.shown_widgets())
            valid_num = len(self.__page.valid_widgets())
            all_num = len(self.__page.all_widgets())
            shown_str = 'Shown: %d / Valid: %d / Total: %d' % (shown_num, valid_num, all_num)
            try:
                self.win().addstr(0, 2, self.__page.title(), curses.A_BOLD)
                self.win().addstr(0, maxx - len(shown_str) - 4, shown_str, curses.A_BOLD)
                self.win().hline(1, 0, curses.ACS_HLINE, 1024, curses.A_BOLD)
            except curses.error:
                pass

    def switch_page(self, page):
        self.__page = page


class MessageBox(object):
    def __init__(self, parent, msg):
        self.msg = msg
        self.parent = parent
        maxy, maxx = parent.getmaxyx()
        width = min(maxx - 20, len(msg)) + 10
        height = 5
        y = (maxy - height) / 2
        x = (maxx - width) / 2
        self.win = parent.derwin(height, width, y, x)
        self.win.erase()
        self.win.attron(curses.color_pair(1))
        self.win.box()
        self.win.attroff(curses.color_pair(1))
        self.win.addstr(2, 4, self.msg, curses.color_pair(0))

    def run(self, anykey=False):
        res = True
        while (1):
            c = self.win.getch()
            if anykey:
                break
            elif c == ord('y'):
                res = True
                break
            elif c == ord('n'):
                res = False
                break
            elif c == ord('q'):
                res = False
                break
        self.win.erase()
        self.win.refresh()
        return res

class PopPad(Widget):
    def __init__(self, name, items, parent, **args):
        self.__offset_x = 0
        self.__offset_y = 0
        self.__name = name

        maxy, maxx = parent.getmaxyx()
        width = maxx - 100
        height = 10
        Widget.__init__(self, height, width, parent)
        self.resize(height, width)
        y = (maxy - height - self.__offset_y) / 2
        x = (maxx - width - self.__offset_x) / 2
        self.mvwin(self.__offset_y + y, self.__offset_x + x)
        self.move(self.__offset_y + y, self.__offset_x + x)

    def __do_key(self):
        ch = self.win().getch()
        stopFlg = False
        if ch in (ord("q"), ord("Q")):
            stopFlg = True

    def __redraw(self):
        self.win().erase()
        self.win().attron(curses.color_pair(1))
        self.win().box()
        self.win().attroff(curses.color_pair(1))
        self.win().addstr(0, 2, ' %s ' % self.__name, curses.color_pair(3))

    def run(self):
        self.__redraw()
        while(True):
            if self.__do_key():
                self.win().erase()
                self.win().refresh()
                return
            self.__redraw()
            self.win().refresh()

class SelectionBox(Widget):
    __padding_left = 5
    __padding_top = 0
    __offset_y = 0
    __offset_x = 0
    __chr_list = 'abcdefghimorstuvwxyzABCDEFGHIMORSTUVWXYZ0123456789'
    __hot_key = False

    def __init__(self, name, items, parent, **args):
        self.__index = 0
        self.__name = name
        self.items = items
        self.parent = parent
        self.__start_idx = 0
        self.__stop_idx = 0
        s = list(self.__chr_list)
        shuffle(s)
        self.__chr_list = ''.join(s)
        self.__offset_y = args.get('offset_y', self.__offset_y)
        self.__offset_x = args.get('offset_x', self.__offset_x)
        self.__hot_key = args.get('hot_key', self.__hot_key)

        maxy, maxx = parent.getmaxyx()
        width = max(len(name) + 6, max([len(it) + 5 for it in items]))
        height = min(len(items) + 2, maxy - self.__offset_y)
        Widget.__init__(self, height, width, parent)
        self.resize(height, width)
        y = (maxy - height - self.__offset_y) / 2
        x = (maxx - width - self.__offset_x) / 2
        self.mvwin(self.__offset_y + y, self.__offset_x + x)
        self.move(self.__offset_y + y, self.__offset_x + x)
        self.win().nodelay(1)
        self.win().timeout(0)
        self.win().keypad(1)
        self.__stop_idx = self.__start_idx + self.height() - 2

    def __do_key(self):
        ch = self.win().getch()
        stop = False
        if self.__fm is not None and ch != -1:
            self.__fm()
            self.__fm = None
        if ch in [ ord('j'), ord('\t'), ord('n'), ord('J'), ord('N'), curses.KEY_DOWN ]:
            if self.__index == len(self.items) - 1:
                self.__start_idx = 0
                self.__stop_idx = self.__start_idx + self.height() - 2
                self.__index = 0
            elif self.__index == self.__stop_idx - 1:
                self.__start_idx = self.__start_idx + 1
                self.__stop_idx =  self.__stop_idx + 1
                self.__index = self.__index + 1
            else:
                self.__index = self.__index + 1
        elif ch in [ ord('k'), ord('K'), ord('p'), ord('P'), curses.KEY_UP ]:
            if self.__index == 0:
                self.__start_idx = max(0, len(self.items) - self.height() + 2)
                self.__stop_idx = self.__start_idx + self.height() - 2
                self.__index = len(self.items) - 1
            elif self.__index == self.__start_idx:
                self.__start_idx = self.__start_idx - 1
                self.__stop_idx =  self.__stop_idx - 1
                self.__index = self.__index - 1
            else:
                self.__index = self.__index - 1
        elif ch in [ ord('\n'), ord(' ') ]:
            stop = True
        elif ch in [ ord('q'), ord('Q') ]:
            self.__index = -1
            stop = True
        elif not self.__hot_key:
            pass
        elif ch in [ ord(c) for c in self.__chr_list ]:
            self.__index = [ ord(c) for c in self.__chr_list ].index(ch) + self.__start_idx
            stop = True
        return stop

    def __redraw(self):
        self.win().erase()
        self.win().attron(curses.color_pair(1))
        self.win().box()
        self.win().attroff(curses.color_pair(1))
        self.win().addstr(0, 2, ' %s ' % self.__name, curses.color_pair(3))
        for idx, item in enumerate(self.items):
            if idx < self.__start_idx or idx >= self.__stop_idx:
                continue

            if not self.__hot_key:
                line = item.center(self.width() - 2)
            elif idx - self.__start_idx < len(self.__chr_list):
                pref = ' %s)' % self.__chr_list[idx - self.__start_idx]
                line = pref + item.center(self.width() - 5)
            else:
                pref = '   '
                line = pref + item.center(self.width() - 5)
            flag = 0
            if idx == self.__index:
                flag = curses.A_BOLD | curses.color_pair(5)
            self.win().addstr(idx - self.__start_idx + self.__padding_top + 1, 1, item, flag)

    def run(self, first_movement=None):
        self.__fm = first_movement
        res = True
        while (1):
            if self.__do_key():
                self.win().erase()
                self.win().refresh()
                return self.__index
            self.__redraw()
            self.win().refresh()


class ColumnCheckBox(Widget):
    __padding_left = 5
    __padding_top = 0
    __margin_top = 4
    __margin_bottom = 4
    __offset_y = 0
    __offset_x = 0

    def __init__(self, name, items, parent, **args):
        self.__index = 0
        self.__name = name
        self.items = items
        self.parent = parent
        self.__start_idx = 0
        self.__stop_idx = 0

        self.__margin_top = args.get('marging_top', self.__margin_top)
        self.__margin_bottom = args.get('marging_bottom', self.__margin_bottom)
        self.__offset_y = args.get('offset_y', self.__offset_y)
        self.__offset_x = args.get('offset_x', self.__offset_x)
        maxy, maxx = parent.getmaxyx()
        width = max(len(name) + 6, max([len(str(it)) + 9 for it in items]))
        height = min(len(items) + 2, maxy - self.__offset_y - self.__margin_top - self.__margin_bottom)
        Widget.__init__(self, height, width, parent)
        self.resize(height, width)
        y = (maxy - height - self.__offset_y) / 2
        x = (maxx - width - self.__offset_x) / 2
        self.mvwin(self.__offset_y + y, self.__offset_x + x)
        self.move(self.__offset_y + y, self.__offset_x + x)
        self.win().nodelay(1)
        self.win().timeout(0)
        self.win().keypad(1)
        self.__stop_idx = self.__start_idx + self.height() - 2

    def __do_key(self):
        ch = self.win().getch()
        stop = False
        if self.__fm is not None and ch != -1:
            self.__fm()
            self.__fm = None
        if ch in [ ord('j'), ord('\t'), ord('n'), ord('J'), ord('N'), curses.KEY_DOWN ]:
            if self.__index == len(self.items) - 1:
                self.__start_idx = 0
                self.__stop_idx = self.__start_idx + self.height() - 2
                self.__index = 0
            elif self.__index == self.__stop_idx - 1:
                self.__start_idx = self.__start_idx + 1
                self.__stop_idx =  self.__stop_idx + 1
                self.__index = self.__index + 1
            else:
                self.__index = self.__index + 1
        elif ch in [ ord('k'), ord('K'), ord('p'), ord('P'), curses.KEY_UP ]:
            if self.__index == 0:
                self.__start_idx = max(0, len(self.items) - self.height() + 2)
                self.__stop_idx = self.__start_idx + self.height() - 2
                self.__index = len(self.items) - 1
            elif self.__index == self.__start_idx:
                self.__start_idx = self.__start_idx - 1
                self.__stop_idx =  self.__stop_idx - 1
                self.__index = self.__index - 1
            else:
                self.__index = self.__index - 1
        elif ch in [ ord(' ') ]:
            self.items[self.__index].enable(not self.items[self.__index].enable())
        elif ch in [ ord('\n') ]:
            stop = True
        elif ch in [ ord('q'), ord('Q') ]:
            self.__index = -1
            stop = True
        return stop

    def __redraw(self):
        self.win().erase()
        self.win().attron(curses.color_pair(1))
        self.win().box()
        self.win().attroff(curses.color_pair(1))
        self.win().addstr(0, 2, ' %s ' % self.__name, curses.color_pair(3))
        for idx, item in enumerate(self.items):
            if idx < self.__start_idx or idx >= self.__stop_idx:
                continue
            pref = ' [%s]' % (item.enable() and 'X' or ' ')
            line = pref + str(item).center(self.width() - 6)
            flag = 0
            if idx == self.__index:
                flag = curses.A_BOLD | curses.color_pair(5)
            self.win().addstr(idx - self.__start_idx + self.__padding_top + 1, 1, line, flag)

    def run(self, first_movement=None):
        self.__fm = first_movement
        res = True
        while (1):
            if self.__do_key():
                self.win().erase()
                self.win().refresh()
                return self.__index
            self.__redraw()
            self.win().refresh()
        if self.__index == -1:
            return []
        else:
            return self.items


class InputBox(Widget):
    def __init__(self, parent, prompt="Password", password=False, width=30):
        self.__index = 0
        self.__name = "name"
        self.__offset_x = 0
        self.__offset_y = 0
        self.__password = password
        height = 3
        win = curses.newwin(0, 0, 0, 0)
        Widget.__init__(self, height, width, win, True)
        self.resize(height, width)
        maxy, maxx = parent.getmaxyx()
        y = (maxy - height - self.__offset_y) / 2
        x = (maxx - width - self.__offset_x) / 2
        self.mvwin(y, x)
        win.box()
        win.refresh()
        self.__prompt = prompt + ": "
        win.addstr(1, 1, self.__prompt)
        win.move(1, 1 + len(self.__prompt))
        self.__textbox = curses.textpad.Textbox(win)
        self.__result = ""

    def validator(self, ch):
        y, x = self.win().getyx()
        if ch == 127:
            new_x = max(x - 1, len(self.__prompt) + 1)
            self.win().delch(y, new_x)
            self.win().insch(' ')
            self.win().move(y, new_x)
            self.__result = self.__result[:-1]
            return 0
        elif ch == 7 or ch == 10:                             # submit
            return 7
        elif x == self.width() - 2:
            return 0
        elif ch < 256:
            self.__result += chr(ch)
            if self.__password:
                return ord('*')
            else:
                return ch

    def run(self):
        curses.noecho()
        curses.curs_set(1)
        self.__textbox.edit(self.validator)
        curses.curs_set(0)
        return self.__result


class GalleryPage(Page):
    def __add_widgets(self):
        tidf = lambda: str(oceanbase.get_current_tenant())
        DEBUG(self.__add_widgets, "cur_tenant_id", tidf())
        time_widget = ColumnWidget("TIME-TENANT", [
            Column("timestamp", lambda stat:
                stat["timestamp"].strftime("%H:%m:%S"),
                    10, True),
            Column("tenant", lambda stat:
                tidf(),
                10, True
                ),
            ], self.win())
        sql_count_widget = ColumnWidget("SQL COUNT", [
            Column("sel", lambda stat:
                    sum([item["sql select count"]
                             for item in stat[tidf()].values()]),
                    6, True),
            Column("ins", lambda stat:
                    sum([ item["sql insert count"]
                             for item in stat[tidf()].values() ]),
                    6, True),
            Column("rep", lambda stat:
                    sum([ item["sql replace count"]
                             for item in stat[tidf()].values() ]),
                    6, True),
            Column("del", lambda stat:
                    sum([ item["sql delete count"]
                             for item in stat[tidf()].values() ]),
                    6, True),
            Column("upd", lambda stat:
                    sum([ item["sql update count"]
                             for item in stat[tidf()].values() ]),
                    6, True),
            Column("cmt", lambda stat:
                    sum([ item["trans commit count"]
                             for item in stat[tidf()].values() ]),
                    6, True),
            Column("fail", lambda stat:
                    sum([ item["sql fail exec count"] + item["sql fail query count"]
                             for item in stat[tidf()].values() ]),
                    6, True)
            ], self.win())
        sql_rt_widget = ColumnWidget("SQL RT", [
            Column("select", lambda stat:
                (sum([ item["sql select time"] for item in stat[tidf()].values() ])
                 / float(sum([ item["sql select count"] for item in stat[tidf()].values() ]) or 1) / 1000),
                8),
            Column("insert", lambda stat:
                (sum([ item["sql insert time"] for item in stat[tidf()].values() ])
                 / float(sum([ item["sql insert count"] for item in stat[tidf()].values() ]) or 1) / 1000),
                8),
            Column("update", lambda stat:
                (sum([ item["sql update time"] for item in stat[tidf()].values() ])
                 / float(sum([ item["sql update count"] for item in stat[tidf()].values() ]) or 1) / 1000),
                8),
            Column("replace", lambda stat:
                (sum([ item["sql replace time"] for item in stat[tidf()].values() ])
                 / float(sum([ item["sql replace count"] for item in stat[tidf()].values() ]) or 1) / 1000),
                8),
            Column("delete", lambda stat:
                (sum([ item["sql delete time"] for item in stat[tidf()].values() ])
                 / float(sum([ item["sql delete count"] for item in stat[tidf()].values() ]) or 1) / 1000),
                8),
            ], self.win())
        net_rt_widget = ColumnWidget("NET RT", [
            Column("net", lambda stat:
                    (sum([ item["rpc net delay"] for item in stat[tidf()].values() ])
                     / float(sum([ item["rpc packet in"] for item in stat[tidf()].values() ]) or 1) / 1000),
                    8),
            Column("frame", lambda stat:
                    (sum([ item["rpc net frame delay"] for item in stat[tidf()].values() ])
                     / float(sum([ item["rpc packet in"] for item in stat[tidf()].values() ]) or 1) / 1000),
                    8),
            ], self.win())
        memory_widget = ColumnWidget("MEMORY", [
            Column("active", lambda stat:
                    mem_str(sum([item["active memstore used"] for item in stat[tidf()].values()])),
                8),
            Column("total", lambda stat:
                    mem_str(sum([item["total memstore used"] for item in stat[tidf()].values()])),
                8),
            Column("freeze", lambda stat:
                    mem_str(sum([item["major freeze limit"] for item in stat[tidf()].values()])),
                8),
            Column("limit", lambda stat:
                    mem_str(sum([item["memstore limit"] for item in stat[tidf()].values()])),
                8)
            ], self.win())
        tableapi_widget = ColumnWidget("TABLE API ROWS/SEC", [
            Column("get", lambda stat:
                   (sum([ item["multi retrieve rows"]
                          for item in stat[tidf()].values() ])
                    + sum([ item["single retrieve execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            Column("put", lambda stat:
                   (sum([ item["multi insert_or_update rows"]
                          for item in stat[tidf()].values() ])
                    + sum([ item["single insert_or_update execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            Column("delete", lambda stat:
                   (sum([ item["multi delete rows"]
                          for item in stat[tidf()].values() ])
                    + sum([ item["single delete execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            Column("insert", lambda stat:
                   (sum([ item["multi insert rows"]
                         for item in stat[tidf()].values() ])
                    + sum([ item["single insert execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            Column("update", lambda stat:
                   (sum([ item["multi update rows"]
                          for item in stat[tidf()].values() ])
                    + sum([ item["single update execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            Column("replace", lambda stat:
                   (sum([ item["multi replace rows"]
                          for item in stat[tidf()].values() ])
                    + sum([ item["single replace execute count"]
                            for item in stat[tidf()].values() ])),
                   6, True),
            ], self.win())

        self.add_widget(time_widget)
        self.add_widget(sql_count_widget)
        self.add_widget(sql_rt_widget)
        self.add_widget(net_rt_widget)
        self.add_widget(memory_widget)
        self.add_widget(tableapi_widget)

    def __init__(self, y, x, h, w, parent):
        Page.__init__(self, parent, Layout(), y, x, h, w)
        try:
            self.__add_widgets()
        except curses.error:
            pass

    def title(self):
        return "Gallery"

    def process_key(self, ch):
        if ch == ord('j'):
            pass
        else:
            Page.process_key(self, ch)

DEV = file("/dev/null", "w")
def DEBUG(*args):
    global DEV
    if Options.debug:
        print >> DEV, "%s in [%s] %s %s" % (time.asctime(), args[0].func_name, args[1], args[2])

class SQLPage(Page):
    def update_widgets(self):
        def observer_info(stat, ip):
            def try_add(name, key, wrapper):
                try:
                    result[name] = wrapper(stat[oceanbase.get_current_tenant()][ip][key])
                except Exception as e:
#                   DEBUG(try_add, "exception", e)
                    pass
            def try_add2(name, key1, key2, wrapper):
                try:
                    result[name] = wrapper(stat[oceanbase.get_current_tenant()][ip][key1] / (stat[oceanbase.get_current_tenant()][ip][key1] + stat[oceanbase.get_current_tenant()][ip][key2]) or 1)
                    DEBUG(try_add2, "wrapper", (stat[oceanbase.get_current_tenant()][ip][key1] + stat[oceanbase.get_current_tenant()][ip][key2]))
                    DEBUG(try_add2, "wrapper", stat[oceanbase.get_current_tenant()][ip][key1])
                except Exception as e:
                    DEBUG(try_add2, "exception", e)
                    pass
            result = dict()
            try_add("active sessions", "active sessions", count_str)
            try_add2("R-cache hit", "row cache hit", "row cache miss", percent_str)
            try_add2("L-cache hit", "location cache hit", "location cache miss", percent_str)
            try_add2("B-cache hit", "block cache hit", "block cache miss", percent_str)
            try_add2("BI-cache hit", "block index cache hit", "block index cache miss", percent_str)
            try_add2("BloomFilter cache hit", "bloom filter cache hit", "bloom filter cache miss", percent_str)
            return result

        svr = "observer"
        self.clear_widgets()
        DEBUG(self.update_widgets, "tenant.svr_list", oceanbase.get_tenant_svr())
        for ms in oceanbase.get_tenant_svr()[svr]:
            ip = ms['ip']
            port = ms['port']
            DEBUG(observer_info, "oceanbase.get_current_tenant()", oceanbase.get_current_tenant())
            ipport = ip + ":" + port
            f = ColumnFactory(svr, ipport)
            DEBUG(self.update_widgets, "f", f)
            widget = HeaderColumnWidget(
                '%s:%d' % (ip,int(port)),
                SQLPage.generate_columns(f),
                self.win(),
                get_header=lambda stat,ip=ip: observer_info(stat,ipport))
            self.add_widget(widget)

    def __init__(self, y, x, h, w, parent):
        Page.__init__(self, parent, Layout(), y, x, h, w)
        try:
            self.update_widgets()
        except curses.error:
            pass

    def select_columns(self):
        if len(self.all_widgets()) > 0:
            all_widgets = [hc_widget.column_widget() for hc_widget in self.all_widgets()]
            columns = all_widgets[0].valid_columns()
            i = ColumnCheckBox("Select Columns", columns, self.parent()).run()
            for w in all_widgets:
                for idx in range(0, len(columns)):
                    w.valid_columns()[idx].enable(columns[idx].enable())
                w.update()
            [hc_widget.resize() for hc_widget in self.all_widgets()]
            self.rearrange()

    def enable_column_group(self, items):
        # enable table api
        if len(self.all_widgets()) > 0:
            all_widgets = [hc_widget.column_widget() for hc_widget in self.all_widgets()]
            columns = all_widgets[0].valid_columns()
            DEBUG(self.enable_column_group, "column count", len(columns))
            enable_columns = []
            for idx in range(0, len(columns)):
                enable_columns.append(0)
            for idx in items:
                enable_columns[idx] = 1
                DEBUG(self.enable_column_group, "enable idx", idx)
            for w in all_widgets:
                for idx in range(0, len(columns)):
                    w.valid_columns()[idx].enable(enable_columns[idx]==1)
                w.update()
            [hc_widget.resize() for hc_widget in self.all_widgets()]
            self.rearrange()

    def process_key(self, ch):
        if (len(self.shown_widgets())) > 0:
            w = self.selected_widget()
        else:
            return
        if ch == ord('m'):
            curses.endwin()
            oceanbase.mysql()
            curses.doupdate()
        elif ch == ord('O') or ch == ord('o'):
            like_str = InputBox(self.win(), prompt="LIKE STR").run()
            oceanbase.show_sql_result("select name,value from __all_virtual_sys_parameter_stat where svr_ip='%s' and svr_type='mergeserver' and name like '%s' order by name" % (w.host(), like_str))
        elif Options.env == 'online' and ch == ord('l'):
            cmd = "ssh -t %s 'less oceanbase/log/mergeserver.log'" % w.host()
            curses.endwin()
            os.system(cmd)
            curses.doupdate()
        elif ch == ord("="):
            self.select_columns()
        elif ch == ord('A') or ch == ord('a'):
            # table api QPS
            self.enable_column_group([16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38])
        elif ch == ord('B') or ch == ord('b'):
            # table api RT
            self.enable_column_group([17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39])
        elif ch == ord('S') or ch == ord('s'):
            # SQL
            self.enable_column_group(range(13))
        else:
            Page.process_key(self, ch)

    def title(self):
        return "ServerPage"

    @staticmethod
    def generate_columns(f):
        enable_sql_columns = True
        enable_table_api_columns = False
        enable_table_api_rt_columns = False
        return [
            #default(SQL)
            f.count("Sql Select Count", "ssc", "sql select count", enable=enable_sql_columns),
            f.time("Sql Select Time", "ssrt", "sql select time", "sql select count", enable=enable_sql_columns),
            f.count("Sql Update Count", "suc", "sql update count", enable=enable_sql_columns),
            f.time("Sql Update Time", "surt", "sql update time", "sql update count", enable=enable_sql_columns),
            f.count("Sql Insert Count", "sic", "sql insert count", enable=enable_sql_columns),
            f.time("Sql Insert Time", "sirt", "sql insert time", "sql insert count", enable=enable_sql_columns),
            f.count("Sql Delete Count", "sdc", "sql delete count", enable=enable_sql_columns),
            f.time("Sql Delete Time", "sdrt", "sql delete time", "sql delete count", enable=enable_sql_columns),
            f.count("Trans Commit Count", "tcc", "trans commit count", enable=enable_sql_columns),
            f.time("Trans Commit Time", "tcrt", "trans commit time", "trans commit count", enable=enable_sql_columns),
            f.count("Sql Execute Local Count", "selc", "sql local count", enable=enable_sql_columns),
            f.count("Sql Execute Remote Count", "serc", "sql remote count", enable=enable_sql_columns),
            f.count("Sql Execute Distributed Count", "sedc", "sql distributed count", enable=enable_sql_columns),
            f.count("Inner SQL Connection Execute Count", "iscec", "inner sql connection execute count"),
            f.time("Inner SQL Connection Execute Time", "iscet", "inner sql connection execute time", "inner sql connection execute count"),
            # Table API
            f.count("Table API table api login count", "login", "table api login count"),

            f.count("Table API single retrieve execute count", "get", "single retrieve execute count", enable=enable_table_api_columns),
            f.time("Table API single retrieve execute time", "g-rt", "single retrieve execute time", "single retrieve execute count", enable=enable_table_api_rt_columns),
            f.count("Table API single insert execute count", "insert", "single insert execute count", enable=enable_table_api_columns),
            f.time("Table API single insert execute time", "i-rt", "single insert execute time", "single insert execute count", enable=enable_table_api_rt_columns),
            f.count("Table API single delete execute count", "delete", "single delete execute count", enable=enable_table_api_columns),
            f.time("Table API single delete execute time", "d-rt", "single delete execute time", "single delete execute count", enable=enable_table_api_rt_columns),
            f.count("Table API single update execute count", "update", "single update execute count", enable=enable_table_api_columns),
            f.time("Table API single update execute time", "u-rt", "single update execute time", "single update execute count", enable=enable_table_api_rt_columns),
            f.count("Table API single insert_or_update execute count", "put", "single insert_or_update execute count", enable=enable_table_api_columns),
            f.time("Table API single insert_or_update execute time", "p-rt", "single insert_or_update execute time", "single insert_or_update execute count", enable=enable_table_api_rt_columns),
            f.count("Table API single replace execute count", "replace", "single replace execute count", enable=enable_table_api_columns),
            f.time("Table API single replace execute time", "r-rt", "single replace execute time", "single replace execute count", enable=enable_table_api_rt_columns),

            f.count("Table API multi retrieve execute count", "mget", "multi retrieve execute count", enable=enable_table_api_columns),
            f.time("Table API multi retrieve execute time", "mg-rt", "multi retrieve execute time", "multi retrieve execute count", enable=enable_table_api_rt_columns),
            f.count("Table API multi insert execute count", "minsert", "multi insert execute count", enable=enable_table_api_columns),
            f.time("Table API multi insert execute time", "mi-rt", "multi insert execute time", "multi insert execute count", enable=enable_table_api_rt_columns),
            f.count("Table API multi delete execute count", "mdelete", "multi delete execute count", enable=enable_table_api_columns),
            f.time("Table API multi delete execute time", "md-rt", "multi delete execute time", "multi delete execute count", enable=enable_table_api_rt_columns),
            f.count("Table API multi update execute count", "mupdate", "multi update execute count", enable=enable_table_api_columns),
            f.time("Table API multi update execute time", "mu-rt", "multi update execute time", "multi update execute count", enable=enable_table_api_rt_columns),
            f.count("Table API multi insert_or_update execute count", "mput", "multi insert_or_update execute count", enable=enable_table_api_columns),
            f.time("Table API multi insert_or_update execute time", "mp-rt", "multi insert_or_update execute time", "multi insert_or_update execute count", enable=enable_table_api_rt_columns),
            f.count("Table API multi replace execute count", "mreplace", "multi replace execute count", enable=enable_table_api_columns),
            f.time("Table API multi replace execute time", "mr-rt", "multi replace execute time", "multi replace execute count", enable=enable_table_api_rt_columns),
            f.count("Table API batch retrieve execute count", "bget", "batch retrieve execute count"),
            f.time("Table API batch retrieve execute time", "bg-rt", "batch retrieve execute time", "batch retrieve execute count"),
            f.count("Table API batch hybrid execute count", "bhybrid", "batch hybrid execute count", enable=enable_table_api_columns),
            f.time("Table API batch hybrid execute time", "bh-rt", "batch hybrid execute time", "batch hybrid execute count", enable=enable_table_api_rt_columns),

            f.count("Table API multi retrieve rows", "rget", "multi retrieve rows"),
            f.time("Table API multi retrieve execute time/row", "rg-rt", "multi retrieve execute time", "multi retrieve rows"),
            f.count("Table API multi insert rows", "rinsert", "multi insert rows"),
            f.time("Table API multi insert execute time/row", "ri-rt", "multi insert execute time", "multi insert rows"),
            f.count("Table API multi delete rows", "rdelete", "multi delete rows"),
            f.time("Table API multi delete execute time/row", "rd-rt", "multi delete execute time", "multi delete rows"),
            f.count("Table API multi update rows", "rupdate", "multi update rows"),
            f.time("Table API multi update execute time/row", "ru-rt", "multi update execute time", "multi update rows"),
            f.count("Table API multi insert_or_update rows", "rput", "multi insert_or_update rows"),
            f.time("Table API multi insert_or_update execute time", "rp-rt", "multi insert_or_update execute time", "multi insert_or_update rows"),
            f.count("Table API multi replace rows", "rreplace", "multi replace rows"),
            f.time("Table API multi replace execute time/row", "rr-rt", "multi replace execute time", "multi replace rows"),
            f.count("Table API batch retrieve rows", "rbget", "batch retrieve rows"),
            f.time("Table API batch retrieve execute time/row", "rbg-rt", "batch retrieve execute time", "batch retrieve rows"),
            f.count("Table API batch hybrid rows", "rbhybrid", "batch hybrid insert_or_update rows"),
            f.time("Table API batch hybrid execute time/row", "rbh-rt", "batch hybrid execute time", "batch hybrid insert_or_update rows"),

            #inner packet
            f.count("RPC Packet In", "rpci", "rpc packet in"),
            f.count("RPC Packet In Bytes", "rpci(B)", "rpc packet in bytes"),
            f.count("RPC Packet Out", "rpco", "rpc packet out"),
            f.count("RPC Packet Out Bytes", "rpco(B)", "rpc packet out bytes"),
            f.count("RPC Deliver Fail", "rpc fail", "rpc deliver fail"),
            f.time("RPC Net Delay", "rpc delay", "rpc net delay"),
            f.count("RPC Net Frame Delay", "rpc frame delay", "rpc net frame delay"),
            #outer packet
            f.count("MySQL Packet In", "mpci", "mysql packet in"),
            f.count("MySQL Packet In Bytes", "mpci(B)", "mysql packet in bytes"),
            f.count("MySQL Packet Out", "mpco", "mysql packet out"),
            f.count("MySQL Packet Out Bytes", "mpco(B)", "mysql packet out bytes"),
            f.count("MySQL Deliver Fail", "mdf", "mysql deliver fail"),
            #request queue
            f.count("Request Enqueue Count", "enqueue", "request enqueue count"),
            f.count("Request Dequeue Count", "dequeue", "request dequeue count"),
            f.time("Request Queue Time", "QT", "request queue time"),
            #transmition
            f.time("Trans Commit Log Time", "tclt", "trans commit log time"),
            f.count("Trans Commit Log Sync Count", "tclsc(sync)", "trans commit log sync count"),
            f.count("Trans Commit LOg Submit Count", "tclsc(submit)", "trans commit log submit count"),
            f.count("Trans System Trans Count", "tstc", "trans system trans count"),
            f.count("Trans User Trans Count", "tutc", "trans user trans count"),
            f.count("Trans Start Count", "tsc", "trans start count"),
            f.count("Trans Total Used Time", "ttut", "trans total used time"),
            f.count("Trans Commit Count", "tcc", "trans commit count"),
            f.time("Trans Commit Time", "tct", "trans commit time"),
            f.count("Trans Rollback Count", "trc", "trans rollback count"),
            f.time("Trans Rollback Time", "trt", "trans rollback time"),
            f.count("Trans Timeout Count", "ttc", "trans timeout count"),
            f.count("Trans Single Partition Count", "tspc", "trans single partition count"),
            #cache
            #FIXME
            f.count("Row Cache Hit", "rch", "row cache hit"),
            f.count("Row Cache Miss", "rcm", "row cache miss"),
            f.count("Block Index Cache Hit", "bich", "block index cache hit"),
            f.count("Block Index Cache Miss", "bicm", "block index cache miss"),
            f.count("Bloom Filter Cache Hit", "bfch", "bloom filter cache hit"),
            f.count("Bloom Filter Cache Miss", "bfcm", "bloom fileter cache miss"),
            f.count("Bloom Filter Filts", "bff", "bloom filter filts"),
            f.count("Bloom Filter Passes", "bfp", "bloom filter passes"),
            f.count("Block Cache Hit", "bch", "block cache hit"),
            f.count("Block Cache Miss", "bcm", "block cache miss"),
            f.count("Location Cache Hit", "lch", "location cache hit"),
            f.count("Location Cache Miss", "lcm", "location cache miss"),
            #resources
            f.count("Active Sessions", "as", "active sessions"),
            f.count("IO Read Count", "iorc", "io read count"),
            f.count("IO Read Delay", "iord", "io read delay"),
            f.count("IO Read Bytes", "ior(B)", "io read bytes"),
            f.count("IO Write Count", "iowc", "io write count"),
            f.count("IO Write Delay", "iowd", "io write delay"),
            f.count("IO Write Bytes", "iow(B)", "io write delay"),
            f.count("Memstore Scan Count", "msc", "memstore scan count"),
            f.count("Memstore Scan Succ Count", "mssc", "memstore scan succ count"),
            f.count("Memstore Scan Fail Count", "msfc", "memstore scan fail count"),
            f.count("Memstore Get Count", "mgc", "memstore get count"),
            f.count("Memstore Get Succ Count", "mgsc", "memstore get succ count"),
            f.count("Memstore Get Fail Count", "mgfc", "memstore get fail count"),
            f.count("Memstore Apply Count", "mac", "memstore apply count"),
            f.count("Memstore Apply Succ Count", "masc", "memstore apply succ count"),
            f.count("Memstore Apply Fail Count", "mafc", "memstore apply fail count"),
            f.count("Memstore Row Count", "mrc", "memstore row count"),
            f.time("Memstore Get Time", "mgt", "memstore get time"),
            f.time("Memstore Scan Time", "mst", "memstore scan time"),
            f.time("Memstore Apply Time", "mat", "memstore apply time"),
            f.count("Memstore Read Lock Succ Count", "mrlsc", "memstore read lock succ count"),
            f.count("Memstore Read Lock Fail Count", "mrlfc", "memstore read lock fail count"),
            f.count("Memstore Write Lock Succ Count", "mwlsc", "memstore write lock succ count"),
            f.count("Memstore Write Lock Fail Count", "mwlfc", "memstore write lock fail count"),
            f.time("Memstore Wait Write Lock Time", "mwwlt", "memstore wait write lock time"),
            f.time("Memstore Wait Read Lock Time", "mwrlt", "memstore wait read lock time"),
            f.count("IO Read Micro Index Count", "iormic", "io read micro index count"),
            f.count("IO Read Micro Index Bytes", "iormib", "io read micro index bytes"),
            f.count("IO Prefetch Micro Block Count", "iopmbc", "io prefetch micro block count"),
            f.count("IO Prefetch Micro Block Bytes", "iopmbb", "io prefetch micro block bytes"),
            f.count("IO Read Uncompress Micro Block Count", "iorumbc", "io read uncompress micro block count"),
            f.count("IO Read Uncompress Micro Block Bytes", "iorumbb", "io read uncompress micro block bytes"),
            f.count("Active Memstore Used", "amu", "active memstore used"),
            f.count("Total Memstore Used", "tmu", "total memstore used"),
            f.count("Major Freeze Trigger", "mft", "major freeze trigger"),
            f.count("Memstore Limit", "ml", "memstore limit"),
            f.count("Min Memory Size", "mms(min)", "min memory size"),
            f.count("Max Memory Size", "mms(max)", "max memory size"),
            f.count("Memory Usage", "mu", "memory usage"),
            f.count("Min CPUS", "mc(min)", "min cpus"),
            f.count("Max CPUS", "mc(max)", "max cpus"),
            #meta
            f.count("Refresh Schema Count", "rsc", "refresh schema count"),
            f.time("Refresh Schema Time", "rst", "refresh schema time"),
            f.count("Partition Table Operator Get Count", "ptogc", "partition table operator get count"),
            f.time("Partition Table Operator Get Time", "ptogt", "partition table operator get time"),
            #clog
            f.count("Submitted To Sliding Window Log Count", "sswlc", "submitted to sliding window log count"),
            f.count("Submitted To Sliding Window Log Size", "sswls", "submitted to sliding window log size"),
            f.count("Index Log Flushed Count", "ilfc", "index log flushed count"),
            f.count("Index Log Flushed Clog Size", "ilfcs", "index log flushed clog size"),
            f.count("Clog Flushed Count", "cfc", "clog flushed count"),
            f.count("Clog Flushed Size", "cfs", "clog flushed size"),
            f.count("Clog Read Count", "crc(read)", "clog read count"),
            f.count("Clog Read Size", "crs", "clog read size"),
            f.count("Clog Disk Read Size", "cdrs", "clog disk read size"),
            f.count("Clog Disk Read Count", "cdrc", "clog disk read count"),
            f.time("Clog Disk Read Time", "cdrt", "clog disk read time"),
            f.count("Clog Fetch Log Size", "cfls", "clog fetch log size"),
            f.count("Clog Fetch Log Count", "cflc", "clog fetch log size"),
            f.count("Clog Fetch Log By Location Size", "cflbls", "clog fetch log by location size"),
            f.count("Clog Fetch Log By Location Count", "cflblc", "clog fetch log by location count"),
            f.count("Clog Read Request Succ Size", "crrss", "clog read request succ size"),
            f.count("Clog Read Request Succ Count", "crrsc", "clog read request succ count"),
            f.count("Clog Read Request Fail Count", "crrfc", "clog read request fail count"),
            f.time("Clog Confirm Delay Time", "ccdt", "clog confirm delay time"),
            f.count("Clog Flush Task Generate Count", "cftgc", "clog flush task generate count"),
            f.count("Clog Flush Task Release Count", "cftrc", "clog flush task release count"),
            f.count("Clog RPC Delay Time", "crdt", "clog rpc delay time"),
            f.count("Clog RPC Count", "crc(rpc)", "clog rpc count"),
            f.count("Clog Non KV Cache Hit Count", "cnkchc", "clog non kv cache hit count"),
            f.time("Clog RPC Request Handle Time", "crrht", "clog rpc request handle time"),
            f.count("Clog RPC Request Count", "crrc", "clog rpc request count"),
            f.count("Clog Cache Hit Count", "cchc", "clog cache hit count")]

class MachineStatPage(Page):
    def update_widgets(self):
        pass

    def title(self):
        return "Machine Stat"

    def __init__(self, y, x, h, w, parent):
        Page.__init__(self, parent, Layout(), y, x, h, w)

class HelpPage(Page):
    def __init__(self, y, x, h, w, parent):
        Page.__init__(self, parent, Layout(), y, x, h, w)
        self.win().bkgd(curses.color_pair(4))

    def redraw(self):
        nline = [0]                       # hack mutating outer variables for python2
        def addline(x, line, attr=0):
            self.win().addstr(nline[0], x, line, attr)
            nline[0] += 1
        def addkeys(keys):
            for key_item in keys:
                if 0 == len(key_item):
                    string = ""
                else:
                    string = "    %-14s: %s" % key_item
                addline(4, string)
            nline[0] += 1
        def addgroup(group_name, keys):
            addline(4, group_name, curses.color_pair(4) | curses.A_BOLD)
            addline(2, "----------------------------------------------", curses.color_pair(4) | curses.A_BOLD)
            addkeys(keys)
        try:
            Page.redraw(self)
            ob_keys = [('c', 'Switch between tenants')]
            addgroup("Global Keys  -  OceanBase", ob_keys)
            widget_keys = [('Tab','Select next widget'),
                           ('m', 'Connect to oceanbase using mysql client'),
                           ('j', 'ssh to selected host')]
            addgroup("Global Keys  -  Widget", widget_keys)
            pages_keys = [('1 F1', 'Help page'), ('2 F2', 'Gallery page'), ('3 F3', 'Observer page'),
                          ('d', 'Delete selected widget'), ('R', 'Restore deleted widgets'),
                          ('=', 'Filter Columns for ObServer Page'),
                          ('a A', 'Show columns for Table API QPS'),
                          ('b B', 'Show columns for Table API RT'),
                          ('s S', 'Show columns for SQL QPS and RT'),
            ]
            addgroup("Global Keys  -  Page", pages_keys)
            test_keys = [('p', 'Messsage box tooltips')]
            addgroup("Global Keys  -  Test", test_keys)
            select_keys = [('DOWN TAB J N', 'Next item'), ('UP K P', 'Previous item'),
                           ('SPC ENTER', 'Select current item'),
                           ('Q q', 'Quit selection box')]
            addgroup("Global Keys  -  Selection Box", select_keys)
            system_keys = [('q', 'quit dooba')]
            addgroup("Global Keys  -  System", system_keys)
            support = [
                ('Author', 'oceanbase'),
                ('Mail', ''),
                ()
                ]
            addgroup("Support", support)
        except curses.error:
            pass

    def title(self):
        return 'Help'


class BlankPage(Page):
    def __init__(self, y, x, h, w, parent):
        Page.__init__(self, parent, Layout(), y, x, h, w)

    def title(self):
        return 'Blank Page'

class Dooba(object):
    def build_oceanbase(self):
        return '''
  ___                       ____
 / _ \  ___ ___  __ _ _ __ | __ )  __ _ ___  ___
| | | |/ __/ _ \/ _` | \'_ \|  _ \ / _` / __|/ _ \\
| |_| | (_|  __/ (_| | | | | |_) | (_| \__ \  __/
 \___/ \___\___|\__,_|_| |_|____/ \__,_|___/\___|'''

    def build_dooba(self):
        return '''
     _             _
  __| | ___   ___ | |__   __ _
 / _` |/ _ \ / _ \| \'_ \ / _` |
| (_| | (_) | (_) | |_) | (_| |
 \__,_|\___/ \___/|_.__/ \__,_|'''

    def __init_curses(self, win):
        self.stdscr = win
        self.stdscr.keypad(1)
        self.stdscr.nodelay(1)
        self.stdscr.timeout(0)
        self.maxy, self.maxx = self.stdscr.getmaxyx()
        curses.curs_set(0)
        curses.noecho()
        self.__term = curses.termname()
        self.__init_colors()

    def __init_colors(self):
        if curses.has_colors():
            curses.use_default_colors()
            curses.init_pair(1, curses.COLOR_RED, -1)   # header widget and status widget
            curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN) # column header
            curses.init_pair(3, curses.COLOR_MAGENTA, -1) # widget title
            curses.init_pair(4, curses.COLOR_YELLOW, -1) # help page color
            curses.init_pair(5, curses.COLOR_RED, curses.COLOR_CYAN)
            curses.init_pair(6, curses.COLOR_GREEN, -1) # column header
            curses.init_pair(7, curses.COLOR_WHITE, -1) # machine stat header
            # curses.init_pair(8, curses.COLOR_GRAY, -1)  # machine stat text

    def __resize_term(self):
        self.maxy, self.maxx = self.stdscr.getmaxyx()
        try:
            self.help_w.move(0, 0)
            self.help_w.mvwin(0, 0)
            self.help_w.resize(2, self.maxx)
            self.stat_w.move(self.maxy - 2, 0)
            self.stat_w.resize(2, self.maxx)
            for page in self.__all_page:
                page.resize(self.maxy - 4, self.maxx)
        except curses.error:
            pass
        self.stdscr.erase()

    def __do_key(self):
        ch = self.__all_page[self.__page_index].getch()
        if ch == ord('q'):
            curses.endwin()
            return True
        elif ch >= ord('0') and ch <= ord('9'):
            index = ch - ord('0')
            if index > 0 and index < len(self.__all_page):
                self.__page_index = ch - ord('0')
                self.help_w.switch_page(self.__all_page[self.__page_index])
        elif ch >= curses.KEY_F1 and ch <= curses.KEY_F9:
            self.__page_index = ch - curses.KEY_F1
            self.help_w.switch_page(self.__all_page[self.__page_index])
        elif ch == ord('\t'):
            self.__all_page[self.__page_index].select_next()
        elif ch == ord('w'):
            pagename = self.__all_page[self.__page_index].title()
            appname = oceanbase.app
            filename = "%s_%s.dooba.win.bz2" % (appname, pagename)
            tmpf = tempfile.TemporaryFile()
            self.stdscr.putwin(tmpf);
            tmpf.seek(0)
            f = bz2.BZ2File(filename, "w")
            f.write(tmpf.read())
            f.close()
            tmpf.close()
            MessageBox(self.stdscr, "[ INFO ] save screen to %s done!" % filename).run(anykey=True)
        elif ch == ord('p'):
            MessageBox(self.stdscr, "[TEST]What's up? (- -)#").run()
        elif ch == ord('z'):
            items = [('check1  12344', False), ('check2 1', True), ('check3 124328432431', False)]
            CheckBox('Test check box', items, self.stdscr).run()
#       elif ch == ord('i'):
#           result = InputBox(self.stdscr).run()
#           MessageBox(self.stdscr, "[TEST] %s" % result).run(anykey=True)
        elif ch == ord('C'):
            dataid_bk = Options.dataid
            self.stdscr.erase()
            self.__show_logo()
            while True:
                if self.__select_dataid() < 0:
                    Options.dataid = dataid_bk
                    break
                elif self.__update_lms() and self.__select_cluster():
                    break
            if dataid_bk != Options.dataid:
                oceanbase.stop()
                oceanbase.start()
                for page in self.__all_page:
                    page.update()
        elif ch == ord('c'):
            self.__select_cluster()
        elif ch == ord("t"):
            PopPad("Abbreviation", [], self.stdscr).run()
        self.__all_page[self.__page_index].process_key(ch)

    def __run(self):
        while (1):
            self.stdscr.erase()

            self.help_w.redraw()
            self.__all_page[self.__page_index].redraw()
            self.stat_w.redraw()

            if (curses.is_term_resized(self.maxy, self.maxx)):
                self.__resize_term()
            if self.__do_key():
                break

            self.stdscr.refresh()
            sleep(0.05)

    def __select_cluster(self):
        if len(oceanbase.tenant) <= 1:
            idx = 0
        else:
            DEBUG(self.__select_cluster, "tnt.selected", [tnt.selected for tnt in oceanbase.tenant])
            idx = SelectionBox("Select Tenant", [ "[%s] %s " % ("*" if tnt.selected else " ", tnt.tenant_name) for tnt in oceanbase.tenant], self.stdscr).run()
            if True == oceanbase.tenant[idx].selected:
                pass
            else:
                tid = oceanbase.tenant[idx].tenant_id
                tname = oceanbase.tenant[idx].tenant_name
                oceanbase.switch_tenant(tid)
                DEBUG(self.__select_cluster, "global oceanbase", oceanbase)
                DEBUG(self.__select_cluster, "oceanbase.tenant", oceanbase.tenant[idx])
                DEBUG(self.__select_cluster, "oceanbase.tenant[idx]", oceanbase.tenant[idx].selected)
                DEBUG(self.__select_cluster, "oceanbase.get_current_tenant()", oceanbase.get_current_tenant())
                for page in self.__all_page:
                    page.cur_tenant_id = tid
                    page.update()
                DEBUG(self.__select_cluster, "page.cur_tenant_id", [" ".join([str(page.title()), page.cur_tenant_id]) for page in self.__all_page])

    def __show_logo(self):
        self.stdscr.hline(7, 0, curses.ACS_HLINE, 1024, curses.A_BOLD | curses.color_pair(1))
        self.stdscr.refresh()
        oceanbase_width = max([len(line) for line in self.build_oceanbase().split('\n')])
        oceanbase_height = len(self.build_oceanbase().split('\n'))
        ob_win = curses.newwin(oceanbase_height + 1, oceanbase_width + 1, 0, 10)
        ob_win.addstr(self.build_oceanbase(), curses.A_BOLD | curses.color_pair(1))
        ob_win.refresh()

        dooba_width = max([len(line) for line in self.build_dooba().split('\n')])
        dooba_height = len(self.build_dooba().split('\n'))
        dooba_win = curses.newwin(dooba_height + 1, dooba_width + 1, 0, self.maxx - dooba_width - 10)
        dooba_win.addstr(self.build_dooba(), curses.A_BOLD | curses.color_pair(6))
        dooba_win.refresh()

    def __cowsay(self, saying):
        cowsay = str(Cowsay(saying))
        cowsay_width = max([len(line) for line in cowsay.split('\n')])
        cowsay_height = len(cowsay.split('\n'))
        try:
            cowsay_win = curses.newwin(cowsay_height + 1, cowsay_width + 1,
                                   self.maxy - cowsay_height - 2, self.maxx - cowsay_width - 10)
            cowsay_win.addstr(cowsay, curses.color_pair(3))
            cowsay_win.refresh()
            self.__cowsay_win = cowsay_win
        except curses.error:
            pass

    def __search_app(self, search_text, dataid_list):
        ret = []
        for group in dataid_list:
            for dataid in dataid_list[group]:
                if search_text in dataid: ret.append(dataid)
        if not ret:
            ret.append("Could not Find App Name Contains: %s" % search_text)
        return ret

    def __select_dataid(self):
        def clear_cowsay():
            try:
                self.__cowsay_win.erase()
                self.__cowsay_win.refresh()
            except AttributeError:
                pass

        dataid_list = ObConfigHelper().get_dataid_list()
        if len(dataid_list) == 0:
            MessageBox(self.stdcsr, "Can't fetch dataid list, please check your environment").run(anykey=True)
            curses.endwin()
            exit(1)
        idx = SelectionBox("Select OceanBase App Groups", dataid_list, self.stdscr, offset_y=8, hot_key=False).run(first_movement=clear_cowsay)
        tmp_k= ""
        if idx == -2:
            search_text = InputBox(self.stdscr, prompt="App Search").run()
            search_res = self.__search_app(search_text, dataid_list)
            idx = SelectionBox("Searching Results", search_res, self.stdscr, offset_y=8, hot_key=True).run(first_movement=clear_cowsay)
            Options.dataid = search_res[idx]
            oceanbase.update_dataid(Options.dataid)
        else:
            for seq, k in zip(range(len(dataid_list)), dataid_list):
                if seq == idx:
                    tmp_k = k
                    break
            idx = SelectionBox("Select OceanBase Data ID", dataid_list[tmp_k], self.stdscr, offset_y=8, hot_key=True).run(first_movement=clear_cowsay)

            if idx >= 0 and tmp_k in dataid_list.keys():
                Options.dataid = dataid_list[tmp_k][idx]
                oceanbase.update_dataid(Options.dataid)
        return idx

#   def __select_dataid(self):
#       def clear_cowsay():
#           try:
#               self.__cowsay_win.erase()
#               self.__cowsay_win.refresh()
#           except AttributeError:
#               pass

#       dataid_list = ObConfigHelper().get_dataid_list()
#       if len(dataid_list) == 0:
#           MessageBox(self.stdscr, "Can't fetch dataid list, plz check your environment!").run(anykey=True)
#           curses.endwin()
#           exit(1)
#       idx = SelectionBox('Select OceanBase dataID',
#                          dataid_list, self.stdscr, offset_y=8, hot_key=True).run(first_movement=clear_cowsay)
#       if idx >= 0:
#           Options.dataid = dataid_list[idx]
#           oceanbase.update_dataid(Options.dataid)
#       return idx

    def __update_lms(self):
        return oceanbase.check_lms(self.__cowsay)

    def __obssh(self, dataid):
        #oceanbase.update_cluster_info()
        oceanbase.update_tenant_info()
        clusters = oceanbase.cluster
        ipmap = {}
        for clu in clusters:
            for svr in clu.svr_list:
                for s in clu.svr_list[svr]:
                    ip = s['ip']
                    if ip not in ipmap:
                        ipmap[ip] = {}
                    if "server" not in ipmap[ip]:
                        ipmap[ip]["server"] = []
                    ipmap[ip]["id"] = clu.id
                    ipmap[ip]["role"] = clu.role
                    ipmap[ip]["server"].append({'type': svr, 'role': s['role']})
        def get_sign(ipmap):
            name_map = {'rootserver':'R', 'updateserver':'U',
                        'mergeserver':'M', 'chunkserver':'C'}
            sign = ''
            for svr in ipmap["server"]:
                s = name_map[svr['type']]
                if svr['role'] == 2:
                    s = s.lower()
                sign += s
            sign = '<%d:%s>' % (ipmap["id"], ipmap["role"] == 1 and 'MASTR' or 'SLAVE') + ('%4s' % sign).replace(' ', '_')
            return sign
        def sort_cmp(l, r):
            cmp0 = cmp(l[1], r[1])
            cmp1 = cmp(l[0], r[0])
            if cmp0 != 0:
                return cmp0
            else:
                return cmp1

        iplist = sorted([(ip, get_sign(ipmap[ip])) for ip in ipmap.keys()], cmp=sort_cmp)
        idx = SelectionBox("select server (%s)" % dataid,
                           ["   %-16s  |  %14s " % (info[0], info[1]) for info in iplist],
                           self.stdscr, hot_key=True).run()
        if idx >= 0:
            curses.endwin()
            oceanbase.ssh(iplist[idx][0])
            curses.doupdate()
            return True
        return False

    def __run_obssh(self):
        if Options.dataid is None:
            while True:
                if self.__select_dataid() < 0:
                    curses.endwin()
                    exit(0)
                if not self.__update_lms():
                    continue
                while self.__obssh(Options.dataid):
                    pass
        else:
            if not self.__update_lms():
                exit(1)
            while self.__obssh(Options.dataid):
                pass
            else:
                exit(0)

    def __run_show_win_file(self):
        self.stdscr.erase()
        bzfh = bz2.BZ2File(Options.show_win_file)
        fh = tempfile.TemporaryFile()
        fh.write(bzfh.read())
        fh.seek(0)
        bzfh.close()
        self.stdscr = curses.getwin(fh)
        self.stdscr.nodelay(0)
        self.stdscr.notimeout(1)
        fh.close()
        ch = self.stdscr.getch()
        curses.endwin()
        exit(0)

    def __init__(self, win):
        self.__all_page = []
        self.__page_index = 2

        self.__init_curses(win)
        minx = 80
        if self.maxx < minx or self.maxy < 20:
            MessageBox(self.stdscr,
                       "[ ERROR ] %dx%d is tooooo smalllll! %dx20 is at least..." % (self.maxx, self.maxy, minx)).run(anykey=True)
            return
        self.__select_cluster()
        oceanbase.update_tenant_info()
        oceanbase.start()
        self.__show_logo()

       #if Options.show_win_file:
       #    self.__run_show_win_file()
       #elif Options.degradation:
       #    self.__run_obssh()
       #elif Options.using_ip_port:
       #    #oceanbase.update_cluster_info()
       #    oceanbase.update_tenant_info()
       #    self.__select_cluster()
       #    oceanbase.start()
       #else:
       #    if Options.dataid is None:
       #        while True:
       #            if self.__select_dataid() < 0:
       #                curses.endwin()
       #                exit(0)
       #            if self.__update_lms() and self.__select_cluster():
       #                break
       #    elif not self.__update_lms():
       #        curses.endwin()
       #        print ("ERROR: update lms failed for [%s]" % Options.dataid)
       #        exit(1)
       #    elif not self.__select_cluster():
       #        exit(0)
       #    oceanbase.start()

        self.stat_w = StatusWidget(self.stdscr)
        self.help_w = HeaderWidget(self.stdscr)

        self.__all_page.append(BlankPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))        # 0
        self.__all_page.append(HelpPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))         # 1
        self.__all_page.append(GalleryPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))      # 2
        self.__all_page.append(SQLPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))          # 3
        # self.__all_page.append(HistoryPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))      # 4
        # self.__all_page.append(BianquePage(2, 0, self.maxy - 4, self.maxx, self.stdscr))      # 5
        # self.__all_page.append(MachineStatPage(2, 0, self.maxy-4, self.maxx, self.stdscr))    # 6
        # self.__all_page.append(BlankPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))        # 7
        # self.__all_page.append(BlankPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))        # 8
        # self.__all_page.append(BlankPage(2, 0, self.maxy - 4, self.maxx, self.stdscr))        # 9

        self.__run()


class DoobaMain(object):
    '''NAME
        dooba - A curses powerful tool for OceanBase admin, more than a monitor

SYNOPSIS
        dooba [OPTIONS]

OPTIONS

    ·   --host=HOST, -h HOST

        Connect to OceanBase on the given host.

    ·   --port=PORT, -P PORT

        The TCP/IP port to use for connecting to OceanBase server.

    ·   --user=USER, -u USER

        The user to use for connecting to OceanBase server.

    ·   --password=PASSWORD, -p PASSWORD

        The password to use for connecting to OceanBase server.

EXAMPLES

    ./dooba -h127.0.0.1 -P2800 -uroot
    '''

    def __usage(self):
        print('Usage: dooba [-h|--host=HOST] [-P|--port=PORT] [-u|--user=USER] [-p|--password=PASSWORD] [--tenant=TENANT]')
        #print('Usage: dooba --show dooba_win_file')

    def __set_env(self):
        setlocale(LC_ALL, "en_US.UTF-8")
        environ['TERM'] = 'xterm'

    def __parse_options(self):
        try:
            opts, args = getopt(sys.argv[1:], '?dh:i:I:p:P:su:D',
                                ['debug', 'help', 'host=', 'interval=', 'port=',
                                 'password=', 'supermode', 'user=', 'dataid=',
                                 'online', 'offline', 'machine-interval=', 'degradation',
                                 'show=', 'daemon', 'http', 'start', 'stop', 'restart',
                                 'http-port=', 'tenant=', 'tenant_id='])
        except GetoptError as err:
            print str(err) # will print something like "option -a not recognized"
            self.__usage()
            exit(2)
        for o, v in opts:
            if o in ('-?', '--help'):
                print self.__doc__
                exit(1)
            if o in ('-d', '--debug'):
                Options.debug = True
            elif o in ('-h', '--host'):
                Options.host = v
                Options.using_ip_port = True
            elif o in ('-P', '--port'):
                Options.port = int(v)
                Options.using_ip_port = True
            elif o in ('-u', '--user'):
                Options.user = v
            elif o in ('-p', '--password'):
                Options.password = v
            elif o in ('-s', '--supermode'):
                Options.supermode = True
            elif o in ('-i', '--interval'):
                Options.interval = float(v)
            elif o in ('-I', '--machine-interval'):
                Options.machine_interval = float(v)
            elif o in ('--dataid'):
                Options.dataid = v
            elif o in ('--online'):
                Options.env = 'online'
            elif o in ('--offline'):
                Options.env = 'offline'
            elif o in ('-D', '--degradation'):
                Options.degradation = True
            elif o in ('--show'):
                Options.show_win_file = v
            elif o in ('--http'):
                Options.http = True
            elif o in ('--start'):
                Options.daemon_action = 'start'
            elif o in ('--stop'):
                Options.daemon_action = 'stop'
            elif o in ('--restart'):
                Options.daemon_action = 'restart'
            elif o in ('--daemon'):
                Options.daemon = True
            elif o in ('--http-port'):
                Options.http_port = int(v)
            elif o in ('--tenant'):
                Options.tenant = v
            elif o in ('--tenant_id'):
                Options.tenant_id = int(v)
            else:
                assert False, 'unhandled option [%s]' & o
        return args

    def __ignore_signal(self):
        def signal_handler(signal, frame):
            pass
        signal.signal(signal.SIGINT, signal_handler)

    def __myprint(self, info):
        print info
        print
        self.__usage()

    def __init__(self):
        global oceanbase
        self.__set_env()

        if "print-config" in self.__parse_options():
            print "".join(ObConfigHelper().get_config(Options.dataid))
            ObConfigHelper().get_dataid_list()
            exit(0)
        if not Options.show_win_file:
            oceanbase = OceanBase(Options.dataid)
            if Options.using_ip_port:
                oceanbase.test_alive(do_false=self.__myprint)

        if Options.http:
            pid_file = '/tmp/dooba.%d.pid' % Options.http_port
            if Options.daemon:
                if Options.daemon_action == 'start':
                    HTTPServerDaemon(pid_file).start()
                elif Options.daemon_action == 'stop':
                    HTTPServerDaemon(pid_file).stop()
                elif Options.daemon_action == 'restart':
                    HTTPServerDaemon(pid_file).restart()
            else:
                try:
                    HTTPServerDaemon(pid_file).run()
                except KeyboardInterrupt:
                    pass
        else:
            try:
                curses.wrapper(Dooba)
            except KeyboardInterrupt:
                pass


class HTTPServerDaemon(Daemon):
    def run(self):
        #oceanbase.update_cluster_info()
        oceanbase.update_tenant_info()
        if (Options.tenant_id is not None):
            oceanbase.switch_tenant(Options.tenant_id)
        elif (Options.tenant is not None):
            oceanbase.switch_tenant(Options.tenant)
        oceanbase.start()
        server = BaseHTTPServer.HTTPServer(('', Options.http_port), WebRequestHandler)
        server.serve_forever()


class JSONDateTimeEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (date, datetime)):
            return obj.isoformat()
        elif isinstance(obj, (timedelta)):
            return 'NULL'
        else:
            return json.JSONEncoder.default(self, obj)


class WebRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    def do_GET(self):
        self.wfile.write('HTTP/1.1 200 OK\nContent-Type: text/html\n\n')
        result = {}
        latest = oceanbase.now()
        for svr in oceanbase.get_tenant_svr()['observer']:
            ip = svr['ip']
            port = svr['port']
            ipport = ip + ":" + port
            f = ColumnFactory('observer', ipport)
            columns = SQLPage.generate_columns(f)
            result["%s:%s"%(ip,port)] = {}
            for c in columns:
                v = c.value(latest)
                if type(v) == str:
                    v = v.strip()
                result["%s:%s"%(ip,port)][c.name()] = v
        self.wfile.write(json.dumps(result, cls=JSONDateTimeEncoder))

def main():
    DoobaMain()

if __name__ == "__main__":
    DoobaMain()
#
# dooba ends here