Blog

import Tkinter as tk
import ecflow  as ec
from threading import Thread
import Queue
import sys
PROGRAM_NAME =  "ecflowview-overview"
BUTTON_FONT  =  ('times', 12)
MONO_FONT    =  ('lucidatypewriter', 14, 'bold')
class MenuBar(tk.Frame):
    def __init__(self, parent):
        tk.Frame.__init__(self, parent)
        self.__helpButton = self.__createHelp()
        self.__helpButton.grid(row=0, column=3)
        self.__updateButton = tk.Button(self, text='Update',
                                        font= BUTTON_FONT,
                                        command= parent.update)
        self.__updateButton.grid(row=0, column=2)
        self.__quitButton = tk.Button(
            self, text='Quit',
            font= BUTTON_FONT, command= self.quit)
        self.__quitButton.grid(row=0, column=0)
        
    def __createHelp(self):
        mb = tk.Menubutton(self, font=BUTTON_FONT,
                        relief= tk.RAISED,
                        text= 'Help')
        menu = tk.Menu(mb)
        mb['menu'] = menu
        return mb
from scrolledlist import ScrolledList
class TaskList(tk.Frame):
    NAME_WIDTH = 80
    NAME_LINES = 22
    def __init__(self, parent, kind):
        tk.Frame.__init__(self, parent)
        self.__kind = kind
        self.__callback = None
        self.__label = tk.Label(self, font=BUTTON_FONT,
                                text= kind)
        rowx = 0
        self.__label.grid(row=rowx, column=0, sticky= tk.W)
        rowx += 1
        self.__scrolledList = ScrolledList(
            self, 
            width= self.NAME_WIDTH,
            height= self.NAME_LINES,
            callback= self.__callback)
        self.__scrolledList.grid(row=rowx, column=0)
    def insert(self, node):
        self.__scrolledList.append(node.get_abs_node_path())
    def clear(self): 
        self.__scrolledList.clear()
running = [True]
class PaceKeeper():
    PACE = 60
    def __init__(self, item, queue): 
        thr = Thread(target=self.process, 
               args=(queue, running))
        self._item = item
        thr.start()
        
    def process(self, queue, running):
        import time
        while running:
            queue.put(self._item.update)
            time.sleep(self.PACE)
    def run(self): self.update()
    def update(self, verbose=False): 
        import time
        while True:
            print time.clock()
            self._item.update()
            time.sleep(self.PACE)
    
class Application(tk.Frame):
    def __init__(self, master=None, client=None, queue=None):
        tk.Frame.__init__(self, master)
        self.__client = client
        self.__queue = queue
        # if client is None: self.__client = ec.Client("localhost", 31415)
        width = 400
        height = 300
        self.canvas = tk.Canvas(width=width, height=height, bg='black')
        self.grid()
        self.createWidgets()
        self.canvas.after(50, self.check_queue)
    def createWidgets(self):
        if 0:
            self.quitButton = tk.Button(self, text='Quit',
                                        command=self.quit)
            self.quitButton.grid(row=1, column=1)
        self.__menuBar = MenuBar(self)
        self.__menuBar.grid(row=0, column=0, columnspan=3,
                            sticky=tk.W)
        self.__wins = dict()
        rowx = 1
        colx = 0
        for kind in ("active", "aborted", "submitted"):
            self.__wins[kind] = TaskList(self, kind)
            self.__wins[kind].grid(row=rowx, column= colx)
            colx += 1
        self.update()
    def check_queue(self):
        try: 
            self.__queue.get(block=False)
        except Queue.Empty: 
            pass
        else: 
            self.update()
        self.canvas.after(50, self.check_queue)
    def process_node(self, node):
        for kind, win in self.__wins.items():
            status = "%s" % node.get_state()
            if status != kind: continue
            win.insert(node)
            print node.get_abs_node_path(), status
    def process_nc(self, node):
        for node in node.nodes:
            if not isinstance(node, ec.Task):
                self.process_nc(node)
            else:
                self.process_node(node)
    def update(self):
        self.__client.sync_local() # get changes, 
        defs = self.__client.get_defs()
        if defs is None: raise BaseException("empty content")
        for kind, win in self.__wins.items(): 
            win.clear()
        print 
        for suite in defs.suites: 
            self.process_nc(suite)
def get_username():
    return pwd.getpwuid( os.getuid() )[ 0 ]

if __name__ == '__main__':
    host = "localhost"
    port = 31415
    if len(sys.argv) > 2:
        host = sys.argv[1]
        port = int(sys.argv[2])
    print "# " + PROGRAM_NAME + ": contact is %s %d" % ( host, port)
    queue = Queue.Queue()
    if port < 65535 or sys.argv[-1] != "sms":
        client = ec.Client(host, port)
        app = Application(client=client, queue=queue)
    else: app = AppSms(host, port, queue)
    app.master.title(PROGRAM_NAME)
    PaceKeeper(app, queue)
    app.mainloop()

import ecflow  as ec
from threading import Thread
import Queue
import sys
try:
    import Tkinter as tk
    import tkFont
except ImportError: # 3.x
    import tkinter as tk # Tkinter
    import tkinter.font as tkFont

import ttk

PROGRAM_NAME =  "ecflowview-treeview"
BUTTON_FONT  =  ('times', 12)
MONO_FONT    =  ('lucidatypewriter', 14, 'bold')
tree_columns = (# 'status', # 'since', 
    'path', "host", "id", "checked", "node")
colors = { 'complete': "yellow",
           'active': "green",
           'aborted': "red",
           'submitted': "turquoise",
           "shutdown": "pink",
           "halted": "violet",
           "queued": "lightblue",
           "unknown": "grey",
           "suspended": "orange" }
displays = dict()

running = True
PACE = 30

def guess_host(node, kind=None): 
    if node is None: return ""

    value = None
    for var in node.variables:
        name = var.name()
        if kind is None and name == "ECF_JOB_CMD":
            if "%WSHOST%" in var.value(): 
                return guess_host(node, "WSHOST")
            elif "%SCHOST%" in var.value(): 
                return guess_host(node, "SCHOST")
            elif "%HOST%" in var.value(): 
                return guess_host(node, "HOST")
            else: value = var.value()
        elif kind == "SCHOST" and name == "SCHOST":
            return var.value()
        elif kind == "WSHOST" and name == "WSHOST":
            return var.value()
        elif kind == "HOST" and name == "HOST":
            return var.value()
        else: pass
    if value is None and node.get_parent():
        return guess_host(node.get_parent(), kind)
            
    return "???"

def guess_qid(node, path=None): 
    if node is None: return ""
    if path is None and not isinstance(node, ec.Task): return ""

    if 0:
        content = "%s" % node
        for line in content.split("\n"): 
            print line
            if "edit ECF_JOB " in line:
                dummy, name, value = line.split()
                print line, dummy, name, value
                return value
    elif 0:
        for var in node.variables:
            if var.name() == "ECF_JOB": return var.value() + ".sub"
    elif path is None: 
        return guess_qid(node.get_parent(), node.get_abs_node_path())
    else: pass
    loc = None
    for var in node.variables:
        if var.name() == "ECF_HOME": loc = var.value() + path; break
    if loc is None and node.get_parent() is not None:
        return guess_qid(node.get_parent(), path)
    elif loc is None: return "???"
    import commands
    a = commands.getstatusoutput("ls -ltr %s*.sub | awk '{print $8}'" % loc)
    item  =a[1].split('\n')
    print path, item[0]
    fd = open(item[0])
    line = "???"
    for line in fd.readlines():
        if "has been submitted" in line:     
            full = line.split()
            if "llsubmit:" in line: return full[3]
            return full[2]
    print "# last: ", line
    return line

    
def guess_check(master, item, node, host, qid):
    SLURM_ROOT="/usr/local/apps/slurm/current/bin"
    qstat="/usr/local/apps/propbs/bin/qstat" # PBS
    llq="/usr/lpp/LoadL/full/bin/llq -f %id %jn %o %c %st %nh"
    import commands
    if "lxa" in host or "lxb" in host or host=="linux_cluster":
        print node, host, qid
        SGE_ROOT="/usr/local/apps/sge"
        SGE_ROOT="/usr/local/apps/sge/sge6_2u5"
        sge="/usr/local/apps/sge/sge6_2u5/bin/lx24-amd64/qstat -u emos -f"
        cmd = "ssh lxab 'SGE_ROOT=%s %s' | grep %d" % (SGE_ROOT, sge, int(qid))        
        a = commands.getstatusoutput(cmd)
        print cmd, a
        if a[0] != 0: return
        full = a[1].split()
        if len(full) > 6 and full[4]=='r':
            print "#YES %s is running since %s %s" % (node, full[5], full[6])
            master._tree.set(item, column="checked", value="%s" % full[6])
        else: print full
    elif "c2a" in host or "c2b" in host or "ecg" in host:
        print node, host, qid
        a = commands.getstatusoutput("rsh %s %s %s | grep %s" % (host, llq, qid, qid))
        print a
    elif "cc" in host:
        print node, host, qid
        a = commands.getstatusoutput("ssh %s qstat %s" % (host, qid))
        print a
    else: print node, host, qid

def textw(clnt, fullpath, kind, node=None):
    # create child window
    win = tk.Toplevel()
    # display message
    if kind == "variables":
        msg = ""
        for var in node.variables:
            msg += "%-20s: %s\n" %(var.name(), var.value())
        message = msg
    elif kind == "info":
        message = "%s" % node
    else: message = clnt.client.get_file(fullpath, kind)
    # text = tk.Label(win, text=message)

    win.title(fullpath + " - " + kind)
    s = tk.Scrollbar(win)
    T = tk.Text(win)

    T.focus_set()
    s.pack(side=tk.RIGHT, fill=tk.Y)
    T.pack(side=tk.LEFT, fill=tk.Y)
    s.config(command=T.yview)
    T.config(yscrollcommand=s.set)

    for i in message.split("\n"):
        T.insert(tk.END, i + "\n")
        T.yview(tk.MOVETO, 1.0)
    
    # ysb = ttk.Scrollbar(text, orien='vertical', 
    #                     command=text.yview)
    # xsb = ttk.Scrollbar(self, orien='horizontal', 
    #                     command=text.xview)
    # text.configure(yscrollcommand=ysb.set, 
    #                xscrollcommand=xsb.set)
    # text.pack()
    # quit child window and return to root window
    # the button is optional here, simply use the corner x of the child window
    # tk.Button(win, text='close', command=win.destroy).pack()

class PaceKeeper():

    def __init__(self, master, queue): 
        self.thr = Thread(target=self.process, 
               args=(queue, running))
        self._master = master
        self.thr.start()
        
    def process(self, queue, running):
        import time
        if not running: self.thr.stop(); return
        queue.put(self._master.update)
        time.sleep(PACE)

    def run(self): self.update()

    def update(self, verbose=False): 
        import time
        if 1: # while running:
            print time.clock()
            self._master.update()
            time.sleep(PACE)

class ContextMenu(object):
    def __init__(self, dad):
        self.dad = dad
        self.cmn = tk.Menu(dad, tearoff=0)
        self.cmn.add_command(label="Info",   command=dad.info)
        self.cmn.add_command(label="Script", command=dad.script)
        self.cmn.add_command(label="Manual", command=dad.manual)
        self.cmn.add_command(label="Job",    command=dad.job)
        self.cmn.add_command(label="Output",    command=dad.jobout)
        self.cmn.add_command(label="Why",    command=dad.why)
        self.cmn.add_command(label="TimeLine",    command=dad.timeline)
        self.cmn.add_command(label="Variables",    command=dad.variables)
        self.cmn.add_command(label="Messages",     command=dad.messages)
        
class MenuBar(tk.Frame):
    def __init__(self, parent):
        tk.Frame.__init__(self, parent)
        self.__helpButton = self.__createHelp()

        self.__updateButton = tk.Button(self, text='Update',
                                        font= BUTTON_FONT,
                                        command= parent.update)

        self.__checkButton = tk.Button(self, text='Check',
                                        font= BUTTON_FONT,
                                        command= parent.check)

        self.__quitButton = tk.Button(
            self, text='Quit',
            font= BUTTON_FONT, command= parent.quit)

        col = 0
        self.__quitButton.grid(row=0, column=col)
        col += 1
        self.__updateButton.grid(row=0, column=col)
        col += 1
        self.__checkButton.grid(row=0, column=col)
        col += 1

        self.__helpButton.grid(row=0, column=col)
        col += 1

        timed = tk.Label(self, font=BUTTON_FONT,
                        textvariable= parent.last_update, )
        timed.grid(row=0, column=col)

        self.__createCheck(col+1)

    def __createHelp(self):
        mb = tk.Menubutton(self, font=BUTTON_FONT,
                        relief= tk.RAISED,
                        text= 'Help')
        menu = tk.Menu(mb)
        mb['menu'] = menu
        menu.add_command(command= self.__url,
                         label="confluence tutorial?")
        menu.add_command(command= self.__url2,
                         label="tkinter?")
        return mb

    def __url2(self): self.__url(1)

    def __url(self, num=0):
        import os
        url = "https://confluence.ecmwf.int/display/ECFLOW/Documentation"

        if num == 1: url = "http://effbot.org/tkinterbook/"

        os.system("firefox " + url)

    def __createCheck(self, col):
        col=4
        
        keys = colors.keys()
        keys.append("unfold")
        for kind in sorted(keys):
            var = tk.IntVar()
            displays[kind] = var
            check = tk.Checkbutton(self, text= kind, variable= var,
                                onvalue= 1, offvalue= 0,)
            if kind in ("active", "aborted", "submitted", "unfold"):
                check.select()
            check.grid(row=0, column=col)
            col += 1
        
def sortby(tree, col, desc, node=''):
    data = []
    for item in tree.get_children(node):
        for kid in tree.get_children(item):
            data.append((tree.set(kid, col), kid, item))

    data.sort(reverse=desc)

    for idx, item in enumerate(data): 
        tree.move(item[1], item[2], idx)
    tree.heading(
        col, command= lambda col= col: sortby(tree, col, int(not desc)))

class Client(object):
    def __init__(self, host, port):
        self.client = ec.Client(host, port)
        self.host   = host
        self.port   = port

    def sync(self, top, parent):
        self.client.sync_local()
        load = self.defs()
        if load is None: print "empty server %s %d" %(self.host, self.port)
        for item in load.suites:
            self.process(top, parent, item)

    def defs(self): return self.client.get_defs()

    def process(self, top, parent, item):
        status = "%s" % item.get_state()
        fullpath = item.get_abs_node_path()

        if not displays[status].get(): return

        unfold = displays["unfold"].get()
        if isinstance(item, ec.Task) or not unfold:
            name = item.name()
            if isinstance(item, ec.Task): 
                host = guess_host(item)
                checked = "nope"
                qid = guess_qid(item)
            else: host= ""; qid = ""; checked = ""
            if unfold: name = fullpath; fullpath = ""
            dad = top._tree.insert(parent, 'end', 
                                     values= (fullpath, 
                                              host,
                                              qid, 
                                              checked,
                                              ),
                                     tags= status,
                                     text=name, open=unfold)
        else: dad = parent
        if 0:
            ilen = tkFont.Font().measure(fullpath)
            if ilen > 80: self._tree.column(1, width=ilen)
            else: pass
        if not isinstance(item, ec.Task):
            for kid in item.nodes: self.process(top, dad, kid)
        else: pass

class Application(tk.Frame):
    def __init__(self, master=None, client=None, queue=None):
        width = 768
        height = 480
        tk.Frame.__init__(self, master, width=width, height=height,)
        self.__queue = queue
        if client is None: 
            HOST = "vsms1"; 
            self.__client = [ ]
            PORT = 43333; self.__client.append(Client(HOST, PORT))
            PORT = 32222; self.__client.append(Client(HOST, PORT))
            PORT = 31415; self.__client.append(Client(HOST, PORT))
            print self.__client
        else: self.__client = [client ]
        # self.canvas = tk.Canvas(width=width, height=height, bg='black')
        self.grid()

        self.last_update = tk.StringVar()
        self.last_update.set("00:00")

        self.createWidgets()
        self.cwn = None
        # self.canvas.after(50, self.check_queue)

    def createWidgets(self):
        self.__menuBar = MenuBar(self)
        row = 0
        self.__menuBar.grid(row=row, column=0, columnspan=3,
                            sticky=tk.W)
        row += 1
        self.__wins = dict()
        rowx = 1
        colx = 0
        if 1:
            self._tree = ttk.Treeview(self, columns=tree_columns,
                                       selectmode='extended',
                                       # justify="right",
                                       # show="headings" # path disappear
                                       )

            ysb = ttk.Scrollbar(self, orien='vertical', 
                                command=self._tree.yview)
            xsb = ttk.Scrollbar(self, orien='horizontal', 
                                command=self._tree.xview)
            self._tree.configure(yscrollcommand=ysb.set, 
                                  # justify="right",
                                  xscrollcommand=xsb.set)

            row=1
            self._tree.grid(row=row, column=0,                                   
                             sticky='nsew', in_=self)
            ysb.grid(row=row, column=len(tree_columns)+1, sticky='wens')
            xsb.grid(sticky='ewns', columnspan=len(tree_columns),)
            self.grid_columnconfigure(0, weight=1,)
            self.grid_rowconfigure(row, weight=1)

            pos = 0
            self.process()
            for kind, color in colors.items():
                self._tree.tag_configure(kind, background=color)

            self._tree.bind("<Double-1>", self.OnDoubleClick)

            # create a popup menu
            self.cmn = ContextMenu(self)
            self._tree.bind("<Button-3>", self.popup)

            for col in tree_columns:
                self._tree.heading(
                    col, text=col.title(),
                    command= lambda c=col: sortby(self._tree, c, 0))
                width = tkFont.Font().measure(col.title())
                if col == "status":
                    ilen = tkFont.Font().measure(kind)
                    if ilen > width: width = ilen
                else: width = 80
                self._tree.column(col, width= width, stretch= True, anchor=tk.E)
                pos += 1
            self.grid()            
            self.pack(fill='both', expand=True)



        self.update()

    def info(self): return self.cmgen("info")
    def manual(self): return self.cmgen("manual")
    def script(self): return self.cmgen("script")
    def job(self): return self.cmgen("job")
    def jobout(self): return self.cmgen("jobout")
    def why(self): return self.cmgen("why")
    def timeline(self): return self.cmgen("timeline")
    def variables(self): return self.cmgen("variables")
    def messages(self): return self.cmgen("messages")

    def cmgen(self, kind="info"): 
        item = self.cwn
        full = self._tree.item(item,"values")
        path = self._tree.item(item,"text")
        print path, full, item
        print "#hello:" # , node.get_abs_node_path()
        upp = item; print  self._tree.parent(upp)
        while self._tree.parent(upp) != '': 
            upp = self._tree.parent(upp)
        idx = self._tree.index(upp)
        if path[0] == '/': fullpath = path
        else: fullpath = full[0]
        if idx < 0 or idx >= len(self.__client): return
        clnt = self.__client[idx]
        defs = clnt.defs()
        node = defs.find_abs_node(fullpath)
        if kind in ("script", "manual", "job", "output", "jobout"):            
            textw(clnt, fullpath, kind)
        elif kind in ("variables",):
            textw(clnt, fullpath, kind, node)
        elif kind in ("info"):
            textw(clnt, fullpath, kind, node)
        else:
            print "# not yet", node

    def popup(self, event):
        item = self._tree.identify('row',event.x,event.y)
        if item is None: print "???"; return
        print "context for", self._tree.item(item,"values"), \
            self._tree.item(item,"text")
        self.cwn = item
        self.cmn.cmn.post(event.x_root, event.y_root)

    def OnDoubleClick(self, event):
        item = self._tree.identify('row',event.x,event.y)
        if item is None: print "???"; return
        print "you clicked on", self._tree.item(item,"values"), \
            self._tree.item(item,"text")

    def check_queue(self):
        try: 
            self.__queue.get(block=False)
        except Queue.Empty: 
            pass
        else: self.update()
        self.canvas.after(50, self.check_queue)

    def unfold(self, item=None):
        if item is None:
            for item in self._tree.get_children(''):
                self.unfold(item)
            return
        item.open()
        for kid in self._tree.get_children(item):
            self.unfold(kid)

    def quit(self):
        global running
        running = False
        self.destroy()
        sys.exit(0)

    def check(self, item=None):
        if item is None:
            for item in self._tree.get_children(''): self.check(item)
            else: pass
        else:
            for kid in self._tree.get_children(item): self.check(kid)    
            full = self._tree.item(item, 'values'), 
            text = self._tree.item(item, 'text'), 
            if len(full[0]) > 3:
                full = full[0]
                if full[1] != "???":
                    unfold = displays["unfold"].get()            
                    if unfold: path = text
                    else: path = full[0]
                    guess_check(self, item, path, full[1], full[2])
          
    def process(self):
        for clt in self.__client:
            parent = self._tree.insert('', 'end', 
                                       text="%s@%s" % (clt.host, 
                                                       clt.port),
                                       open= True)
            clt.sync(self, parent)

    def update(self):
            import time
            now = time.localtime(time.time())
            hhmmss = "%02d:%02d:%02d" % (now.tm_hour, now.tm_min, now.tm_sec)
            self.last_update.set(hhmmss)
            for item in self._tree.get_children(''): self._tree.delete(item)
            self.process()

if __name__ == '__main__':
    if len(sys.argv) > 2:
        HOST = sys.argv[1]
        PORT = int(sys.argv[2])
        print "# " + PROGRAM_NAME + ": contact %s %d" % (HOST, PORT)
        client = Client(HOST, PORT)
    else: client = None
    queue = Queue.Queue()
    app = Application(client=client, queue=queue)
    app.master.title(PROGRAM_NAME)

    PaceKeeper(app, queue)

    app.mainloop()

#!/usr/bin/env python
import ecf as ec
import sys
import time
class Observer(object):
    """ simple ecflow watchdog class """

    def __init__(self, defs, node, port, path):
        super(Observer, self).__init__()
        self.path = path
        self.node = node
        self.port = port
 
    def process_node(self, node):
        status = "%s" % node.get_dstate()
        if status not in ("queued", "complete"):
            print node.get_abs_node_path(), status
        for kid in node.nodes:
            self.process_node(kid)

    def clear(self):
        for n in range(0, 64, 1): print("\r\n")

    def run(self):
        client = ec.Client(self.node, self.port)
        while 1: 
            client.sync_local() # get changes, 
            node = client.get_defs().find_abs_node(self.path)
            assert node is not None
            self.clear()
            self.process_node(node)
            time.sleep(90)

if __name__ == "__main__":
    import os.path
    if len(sys.argv) < 3: 
        node = "localhost"
        port = "31415"
        path = "/"
    else:
        node = sys.argv[1]
        port = sys.argv[2]
        path = sys.argv[3]
    if 1:  client = Observer(None, node, port, path)
    else:  client = ObserverHtml(None, node, port, path)
    client.run()

CSS = "/home/ma/map/http/sms.css"
HEADER = '''<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="refresh" content="600">
  <title>Status tree of {node_full_name} in {hostname}-{hostport}</title>
  <link rel="stylesheet" type="text/css" href="file:{css}">
</head>
<body>
  <table border=2 cellpadding=2> <tr>'''
FOOTER = '''</table>\n</body>\n</html>'''
class ObserverHtml(Observer):
    """ simple ecflow watchdog class + html output """
    def __init__(self, defs, node, port, path):
        super(ObserverHtml, self).__init__(defs, node, port, path)
        self.userdepth = 3
        self.status_mask = ("queued", "complete", "unknown")
        self.maxdepth = 100
        self.openkids = True
    def run(self):
        client = ec.Client(self.node, self.port)
        path   = self.path
        while 1:
            client.sync_local() # get changes, synced with local definition
            node = client.get_defs().find_abs_node(path)
            if 0: assert node is not None
            if node is None: node = client.get_defs() 
            self.html_write(node)
            time.sleep(90)
    def header(self):
        print >>self.fp, HEADER.format(node_full_name=self.path,
                                       hostname= self.node,
                                       css= CSS,
                                       hostport=self.port)
    def tail(self, node=None):
        print >>self.fp, FOOTER
    def countnext(self, anything, depth):
      np = anything;
      n = 0;
      if np is not None and depth > self.maxdepth:    
          self.maxdepth = depth;
      while np is not None:
          n += 1
          np = np.next()
      return n;
    def count(self, np=None, depth=1):
       n = 0;
       if np is None: return
       if ("%s" % np.get_state() not in self.status_mask
           or depth > self.userdepth):
           return
       if depth > self.maxdepth: self.maxdepth = depth;
  
    def html_write(self, np, fpp=None):
      if fpp is None: 
          fpp = open("example.html", "w")
      self.count(np,0);
      self.fp = fpp;
      self.header();
      self.lineno = 0;
      self.table(np,0);
      self.tail(np);
      fpp.close()
    def write_link(self, node, horizontal, base, target):
      print >>self.fp, '<base target="{target}">'.format(target=target)
      for np in node.nodes:
          print >>self.fp,'      <td class="{status}">'.format(status="%s" % np.get_state())
          print >>self.fp,'<a href="{base}/{name}.html">{name}</a>'.format(
              base=base, name=np.name())
          if horizontal and np.next():
              print >>self.fp,"    </tr>"
              print >>self.fp,"    <tr>"
          print >>self.fp, "    </tr>"
    def img(self, name):
        print >>self.fp, "<img src=\"../gifs/%s.gif\" alt=\"[%s]\">" % (name,name)
    def decorations(self, node):
        status =  node.get_state()
        if status == "halted": self.img("halted")
        if status == "shutdown": self.img("shutdown")
        # rerun
        # messages
        # late
        # clock
    def html_links(self, np, fpp=None, title=0, horizontal=0):
      base = os.getenv("htmlbase");
      target = os.getenv("htmltarget");
      if base is not None: base = "od";
      if target is not None: target = "level1";
      self.fp = fpp;
      self.header();
      if title:      print >>self.fp,"      <th>{name}</th>".format(name=np.name())
      if horizontal: print >>self.fp,"    </tr>"
      if np.nodes:   print >>self.fp, "    <tr>"
      self.write_link(np, horizontal, base, target);
      self.tail();
    def table(self, node, depth):
        n = 0
        if node is None: return 0
        # if depth > self.userdepth: return 0 # depth
        try: print node.get_abs_node_path()
        except: pass
        if 1: 
              try:    status = "%s" % node.get_state() # node
              except: 
                  status = node.value()            # attribute
                  print >>self.fp, "<td>%s:%s" % (node.name(),status),"</td>"
                  return 1
              if status in self.status_mask: return 0
              try:
                  print >>self.fp, "<td class='%s'>" % status, "%s" % node.name(),"</td>"
              except:
                  for suite in node.suites: self.table(suite, depth) # Defs
                  return 0
              # decorations?
              if self.openkids:
                  # n += self.table(node.get_repeat(), depth+1)
                  for item in node.meters:
                      n += self.table(item, depth+1)
                  for item in node.events:
                      n += self.table(item, depth+1)
                  for item in node.labels:
                      n += self.table(item, depth+1)
                  
                  i = 0
                  for kid in node.nodes: 
                      if 1: print >>self.fp, "<tr>"
                      n += self.table(kid, depth+1)
                      i += 1
        if n == 0: print >>self.fp, "</tr>"; n=1
        return n

JQUERY = HOME + "jquery-1.10.2.min.js"
SIMPLE_CSS = """
<style type="text/css">
body {background: #ffffff; color: #000000 }
A:link {color: blue}
A:visited {color: purple}
A:active {color: blue}

A:link, A:visited, A:active {text-decoration: underline; }
li.unknown   { background: #bfbfbf }
li.complete  { background: yellow }
li.queued    { background: #add9e7 }
li.submitted { background: #04e1d1 }
li.active    { background: #00ff00 }
li.suspended { background: #ffa600 }
li.aborted   { background: #ff0000 }
li.shutdown  { background: #ffc1cc }
li.halted    { background: #ef83ef }
li.set       { background: #bbbbff }
li.clear     { background: #bbbbbb }

/* ul li { list-style: disc; }
ul ul li { list-style: circle; }
ul ul ul li { list-style: square; } */
</style>
"""
# NODES: def, suite, family, task
# ATTRIBUTES: autocancel, clock, complete, cron, date, day, defstatus, edit
# event, inlimit, label, late, limit, meter, repeat, time, today, trigger

class ObserverJS(Observer):
    """ simple ecflow watchdog class + html output """

    def __init__(self, defs, node, port, path, fname="ecflow.html"):
        super(ObserverJS, self).__init__(defs, node, port, path)
        self.fname = fname
        self.status_mask = ("queued", "complete", "unknown")

    def process_node(self, node, fp):
        if node is None: return
        elif isinstance(node, ec.Alias): return 
        elif isinstance(node, ec.Defs):
            status = "%s" % node.get_server_state()
            status = status.lower()
            name   = "%s@%s" % (self.node, self.port)
        else: 
            status = "%s" % node.get_state()
            name   = node.name()
            if status in self.status_mask: return

        print >>fp, "<ul>"
        print >>fp, "<li class='%s fold'>%s" % (status, name)      
        if isinstance(node, ec.Defs):
            for kid in node.suites:
                self.process_node(kid, fp)
        else:
            for kid in node.nodes:
                self.process_node(kid, fp)
        print >>fp, "</li></ul>"

    def gen_html(self, fp, node):
        print >>fp, HEADER.format(node_full_name= self.path,
                                  hostname= self.node,
                                  css= "", # CSS,
                                  hostport= self.port)

        print >>fp,"""
<h2>Status tree of {node_full_name} in {hostname}-{hostport}
</h2>""".format(node_full_name= self.path,
                hostname= self.node,
                hostport= self.port)

        print >>fp, """<!-- 
wget http://code.jquery.com/jquery-1.10.2.min.js
python ecflow_client.py localhost 31415 /verify example.html
firefox example.html
wget https://github.com/mbostock/d3/archive/master.zip # http://d3js.org/
# http://www.randelshofer.ch/treeviz/
-->
<script src="{jquery}"></script>""".format(jquery= JQUERY)
        print >>fp, SIMPLE_CSS

        if isinstance(node, ec.Defs):
            status = "%s" % node.get_server_state()
            d = [ { "name": "%s-%s" % (self.node, self.port),
                  "status": status.lower(),
                  "kids": [ self.get_dict(kids)
                            for kid in node.suites ] } ]
        elif (isinstance(node, ec.Suite) 
              or isinstance(node, ec.Family) 
              or isinstance(node, ec.Task)):
            d = [ self.get_dict(node) ]

        else: d = {}; print type(node); return
        import json
        print d
        print >>fp, """<script type="text/javascript">
var html = [];
var tree= """, json.dumps(d), """;

function createList(arr) {
html.push('<ul>');

$.each(arr, function(index, item) {
if (item==null) { return; }
html.push("<li class='" + item.status + " fold'>"+item.name);
if (item.kids) { createList(item.kids); }
html.push("</li>"); });

html.push('</ul>');
}

createList(tree);
$('body').append(html.join(''));
</script>
"""
        self.process_node(node, fp)
        print >>fp, FOOTER

    def get_dict(self, node):
        status = "%s" % node.get_state()
        if status in self.status_mask: return # reduce output
        return { "name": node.name(),
                 "status": status.lower(),
                 "kids": [ self.get_dict(kid) 
                           for kid in node.nodes ]}
    def run(self):
        client = ec.Client(self.node, self.port)
        while 1: 
            client.sync_local() # get changes, 
            if self.path == "/": node = client.get_defs()
            else: node = client.get_defs().find_abs_node(self.path)
            if 0: assert node is not None

            fp = open(self.fname, "w")
            self.gen_html(fp, node)
            fp.close()
            time.sleep(90)

SIZE = {
    "aborted": 50,
    "queued": 10,
    "complete": 10,
    "unknown": 10,
    "submitted": 30,
    "active": 50,
    "running": 10,
    "shutdown": 30,
    "halted": 50,
}

STATUS = {
    "aborted": 5,
    "queued": 3,
    "complete": 2,
    "unknown": 10,
    "submitted": 4,
    "active": 6,
    "running": 10,
    "shutdown": 7,
    "suspended": 1,
    "halted": 8,
}

class ObserverD3(Observer):
    """ simple ecflow watchdog class + html output """

    def __init__(self, defs, node, port, path, fname="ecflow.html"):
        super(ObserverD3, self).__init__(defs, node, port, path)
        self.fname = fname
        self.status_mask = ("queued", "complete", "unknown")
        self.d3body = """
<!DOCTYPE html>
<meta charset="utf-8">
<style>

body {
  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
  margin: auto;
  position: relative;
  width: 960px;
}

form {
  position: absolute;
  right: 10px;
  top: 10px;
}

.node {
  border: solid 1px white;
  font: 10px sans-serif;
  line-height: 12px;
  overflow: hidden;
  position: absolute;
  text-indent: 2px;
}

</style>
<form>
  <label><input type="radio" name="mode" value="size" checked>Size</label>
  <label><input type="radio" name="mode" value="count"> Count</label>
</form>
<script src="http://d3js.org/d3.v3.min.js"></script>
<script>

var margin = {top: 40, right: 10, bottom: 10, left: 10},
    width = 960 - margin.left - margin.right,
    height = 500 - margin.top - margin.bottom;

var color = d3.scale.category20c();

var treemap = d3.layout.treemap()
    .size([width, height])
    .sticky(true)
    .value(function(d) { return d.size; });

var div = d3.select("body").append("div")
    .style("position", "relative")
    .style("width", (width + margin.left + margin.right) + "px")
    .style("height", (height + margin.top + margin.bottom) + "px")
    .style("left", margin.left + "px")
    .style("top", margin.top + "px");

d3.json("ecflow.json", function(error, root) {
  var node = div.datum(root).selectAll(".node")
      .data(treemap.nodes)
    .enter().append("div")
      .attr("class", "node")
      .call(position)
      .style("background", function(d) { return d.children ? color(d.name) : null; })
      .text(function(d) { return d.childrenkids ? null : d.name; });

  d3.selectAll("input").on("change", function change() {
    var value = this.value === "count"
        ? function() { return 1; }
        : function(d) { return d.size; };

    node
        .data(treemap.value(value).nodes)
      .transition()
        .duration(1500)
        .call(position);
  });
});

function position() {
  this.style("left", function(d) { return d.x + "px"; })
      .style("top", function(d) { return d.y + "px"; })
      .style("width", function(d) { return Math.max(0, d.dx - 1) + "px"; })
      .style("height", function(d) { return Math.max(0, d.dy - 1) + "px"; });
}

</script>
"""

    def process_node(self, node, fp):
        if node is None: return
        elif isinstance(node, ec.Alias): return 
        elif isinstance(node, ec.Defs):
            status = "%s" % node.get_server_state()
            status = status.lower()
            name   = "%s@%s" % (self.node, self.port)
        else: 
            status = "%s" % node.get_state()
            name   = node.name()
            if status in self.status_mask: return

        print >>fp, "<ul>"
        print >>fp, "<li class='%s fold'>%s" % (status, name)      
        if isinstance(node, ec.Defs):
            for kid in node.suites:
                self.process_node(kid, fp)
        else:
            for kid in node.nodes:
                self.process_node(kid, fp)
        print >>fp, "</li></ul>"
        # def, suite, family, task
        # autocancel, clock, complete, cron, date, day, defstatus, edit
        # event, inlimit, label, late, limit, meter, repeat, time, today, trigger

    def get_dict(self, node):
        if isinstance(node, ec.Alias): return 
        status = "%s" % node.get_state()
        try: a = SIZE[status],
        except: print SIZE.keys(), status; raise
        return { "name": node.name(),
                "status": STATUS[status],
                "state": status,
                "size":  SIZE[status], 
                "children": [ self.get_dict(kid) for kid in node.nodes ]}

    def run(self):
        client = ec.Client(self.node, self.port)
        fp = open(self.fname, "w")
        print >> fp, self.d3body
        fp.close()
        while 1: 
            client.sync_local() # get changes, 
            if self.path == "/": node = client.get_defs()
            else: node = client.get_defs().find_abs_node(self.path)
            if 0: assert node is not None

            if isinstance(node, ec.Defs):
                status = "%s" % node.get_server_state()
                d = {"name": "%s-%s" % (self.node, self.port),
                     "status": STATUS[status.lower()],
                     "size":  SIZE[status.lower()],
                     "state": status,
                     "children": [self.get_dict(kid) for kid in node.suites]}

            elif isinstance(node, ec.Alias): pass

            elif (isinstance(node, ec.Suite) 
                  or isinstance(node, ec.Family) 
                  or isinstance(node, ec.Task)):
                d = self.get_dict(node)
                     
            else: d = {}; print type(node) # FIXME
            import json
            print d
            fp = open("ecflow.json", "w")
            print >>fp, json.dumps(d)
            fp.close()
            time.sleep(90)

class ObserverD3SunBurst(ObserverD3):
    def __init__(self, defs, node, port, path, fname="ecflow.html"):
        super(ObserverD3SunBurst, self).__init__(defs, node, port, path, fname)
        self.d3body = """
<!DOCTYPE html>
<meta charset="utf-8">
<style>

path {
  stroke: #fff;
  fill-rule: evenodd;
}

</style>
<body>
<script src="http://d3js.org/d3.v3.min.js"></script>
<script>

var width = 960,
    height = 700,
    radius = Math.min(width, height) / 2;

var x = d3.scale.linear()
    .range([0, 2 * Math.PI]);

var y = d3.scale.sqrt()
    .range([0, radius]);

var color = d3.scale.category20c();

var svg = d3.select("body").append("svg")
    .attr("width", width)
    .attr("height", height)
  .append("g")
    .attr("transform", "translate(" + width / 2 + "," + (height / 2 + 10) + ")");

var partition = d3.layout.partition()
    .value(function(d) { return d.size; });

var arc = d3.svg.arc()
    .startAngle(function(d) { return Math.max(0, Math.min(2 * Math.PI, x(d.x))); })
    .endAngle(function(d) { return Math.max(0, Math.min(2 * Math.PI, x(d.x + d.dx))); })
    .innerRadius(function(d) { return Math.max(0, y(d.y)); })
    .outerRadius(function(d) { return Math.max(0, y(d.y + d.dy)); });

d3.json("ecflow.json", function(error, root) {
  var path = svg.selectAll("path")
      .data(partition.nodes(root))
    .enter().append("path")
      .attr("d", arc)
      .attr("name", function(d) { return d.name; })
      .style("fill", function(d) { return color((d.children ? d : d.parent).name); })
      .on("click", click);

  function click(d) {
    path.transition()
      .duration(750)
      .attrTween("d", arcTween(d));
  }
});

d3.select(self.frameElement).style("height", height + "px");

// Interpolate the scales!
function arcTween(d) {
  var xd = d3.interpolate(x.domain(), [d.x, d.x + d.dx]),
      yd = d3.interpolate(y.domain(), [d.y, 1]),
      yr = d3.interpolate(y.range(), [d.y ? 20 : 0, radius]);
  return function(d, i) {
    return i
        ? function(t) { return arc(d); }
        : function(t) { x.domain(xd(t)); y.domain(yd(t)).range(yr(t)); return arc(d); };
  };
}

</script>
"""