---

Hillock.java

Go to the documentation of this file.

package net.threebit.utils.sosc;

/*
        Copyright 2003 Kevin O'Donnell

        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 2 of the License, 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; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

import java.sql.*;
import java.util.*;
import java.util.logging.*;

public class Hillock {

        private static final Logger logger = Logger.getLogger("net.threebit.utils.sosc");

        private static boolean enabled = true;

        private static final ThreadLocal threadLocal = new ThreadLocal();

        private static final LinkedList workQueue = new LinkedList();

        public static void startPath (String name) {
                if (! enabled) { return; }
                Long started = new Long(System.currentTimeMillis());

                // Make sure any existing path has been ended.
                endPath();

                HashMap map = local();
                synchronized (map) {
                        map.put("started", started);
                        map.put("name", name);
                        map.put("nodes", new LinkedList());
                }

        }

        public static void endPath() {
                if (! enabled) { return; }

                Long ended = new Long(System.currentTimeMillis());
                Map work = new HashMap();

                HashMap map = local();
                synchronized (map) {
                        // Nothing to do
                        if (map.get("name") == null) { return ; }

                        // Mark the time the path was ended.
                        map.put("ended", ended);

                        // Prepare the data object that goes into the worker threads queue
                        work.put("name", map.get("name"));
                        work.put("started", map.get("started"));
                        work.put("ended", map.get("ended"));
                        work.put("nodes", map.get("nodes"));

                        // Since the path has ended, no data should stay around
                        map.clear();
                }

                synchronized (workQueue) {
                        workQueue.add(work);
                        workQueue.notifyAll();
                }

        }

        public static void startNode (String name) {
                if (! enabled) { return; }

                Long started = new Long(System.currentTimeMillis());
                Map newNode = new HashMap();
                newNode.put("name",name);
                newNode.put("started", started);

                HashMap map = local();
                synchronized (map) {
                        LinkedList nodes = (LinkedList) map.get("nodes");

                        if (nodes.size() == 0) {
                                // Outlier condition; first node in the path.
                                nodes.add(newNode);
                                return;
                        }

                        Map node = (Map) nodes.getLast();
                        if (node.get("ended") != null) {
                                // 1 dimensional case; just add the node to the end of the list
                                // with a null parent (this is a "top level" node on the path.
                                nodes.add(newNode);
                        }
                        else {
                                // The top level node is not closed, so this node will be
                                // placed as a leaf somewhere below it.  Search for the appropriate
                                // location.
                                while (true) {
                                        LinkedList children = (LinkedList) node.get("children");
                                        if (children == null || children.size() == 0) {
                                                // This is the first child added to the node.
                                                if (children == null) { children = new LinkedList(); }
                                                children.add( newNode );
                                                node.put("children",children);
                                                break;
                                        }
                                        else {
                                                // Some children already exist.  If the last child has ended,
                                                // then the new node is a sibling to it.  If it has not been
                                                // ended, then the new node should be added underneath it.
                                                Map child = (Map) children.getLast();
                                                if (child.get("ended") != null) {
                                                        // New node is a sibling
                                                        children.add( newNode );
                                                        break;
                                                }
                                                else {
                                                        // Last child has not ended, so reset "node" to be the 
                                                        // last child and loop to continue searching
                                                        node = child;
                                                }
                                        }
                                }
                        }
                }
        }

        public static void endNode() {
                if (! enabled) { return; }

                Long ended = new Long(System.currentTimeMillis());
                HashMap map = local();
                synchronized (map) {
                        LinkedList nodes = (LinkedList) map.get("nodes");
                        if (nodes == null || nodes.size() == 0) { return; }
                        Map node = (Map) nodes.getLast();
                        while (true) {
                                LinkedList children = (LinkedList) node.get("children");
                                if (children == null || children.size() == 0) {
                                        // This node is being ended
                                        if (node.get("ended") != null) { throw new RuntimeException(" Assert failed: tried to 'end' a node twice"); }
                                        node.put("ended",ended);
                                        break;
                                }
                                else {
                                        // This node has children;
                                        Map child = (Map) children.getLast();
                                        if (child.get("ended") == null) {
                                                // The last child has not ended; reset "node" to be the child and continue
                                                node = child;
                                        }
                                        else {
                                                // THe last child has ended; therefore, end the current node
                                                node.put("ended",ended);
                                                break;
                                        }
                                }
                        }
                }
        }

        public static void node (String name) {
                startNode(name);
                endNode();
        }

        public static HashMap local() {
                synchronized (threadLocal) {
                        HashMap m = (HashMap) threadLocal.get();
                        if (m == null) {
                                m = new HashMap();
                                threadLocal.set( m );
                        }
                        return m;
                }
        }

        public static DbTool db() throws Exception {
                return new DbTool(jdbcDriverClass(), jdbcURL(), jdbcUserName(), jdbcPassword());
        }

        public static String jdbcDriverClass () { return System.getProperty("net.threebit.utils.sosc.Hillock.jdbcDriverClass"); }

        public static String jdbcURL () { return System.getProperty("net.threebit.utils.sosc.Hillock.jdbcURL"); }

        public static String jdbcUserName () { return System.getProperty("net.threebit.utils.sosc.Hillock.jdbcUserName"); }

        public static String jdbcPassword () { return System.getProperty("net.threebit.utils.sosc.Hillock.jdbcPassword"); }

        static {

                Thread worker = new Thread() {
                        public void run() {
                                try {
                                        LinkedList workList = new LinkedList();
                                        while (true) {
        
                                                // check/wait for work.
                                                synchronized (workQueue) {
        
                                                        // Wait for work to appear if there isnt any already
                                                        if (workQueue.size() == 0) { workQueue.wait(); }
        
                                                        // Copy the work out of workQueue so we can release the 
                                                        // lock and continue to the database work.
                                                        workList.addAll( workQueue );
                                                        workQueue.clear();
                                                }

                                                DbTool db = null;
                                                try {
                                                        db = db();
                                                        Connection c = db.getConnection();
                                                        c.setAutoCommit(false);
                                                        c.setTransactionIsolation( Connection.TRANSACTION_SERIALIZABLE );
                                                        PreparedStatement ps = c.prepareStatement(" insert into hillockPaths (name, started, ended) values (?,?,?) ");
                                                        PreparedStatement ns = c.prepareStatement(" insert into hillockPathNodes (name, started, ended, path, parent) values (?,?,?,?,?) ");

                                                        for (Iterator i = workList.iterator(); i.hasNext(); ) {
                                                                Map path = (Map) i.next();

                                                                Long pathEnded = (Long) path.get("ended");
                                                                LinkedList nodes = (LinkedList) path.get("nodes");

                                                                ps.setString(1,(String) path.get("name"));
                                                                ps.setTimestamp(2,new Timestamp(((Long) path.get("started")).longValue()));
                                                                ps.setTimestamp(3,new Timestamp(((Long) path.get("ended")).longValue()));
                                                                ps.execute();
                                                                ps.clearParameters();
                                                                int pathId = db.getInt(" select max(id) from hillockPaths ");

                                                                LinkedList stack = new LinkedList();
                                                                stack.addAll( (List) nodes );

                                                                while (stack.size() > 0) {
                                                                        Map node = (Map) stack.removeFirst();

                                                                        Integer parent = (Integer) node.get("parent"); 
                                                                        Long nodeEnded = (Long) node.get("ended");
                                                                        if (nodeEnded == null) { nodeEnded = pathEnded; }

                                                                        ns.setString(1, (String) node.get("name"));
                                                                        ns.setTimestamp(2,new Timestamp(((Long) node.get("started")).longValue()));
                                                                        ns.setTimestamp(3,new Timestamp(nodeEnded.longValue()));
                                                                        ns.setInt(4, pathId);
                                                                        if (parent == null) { ns.setNull(5, Types.INTEGER); }
                                                                        else { ns.setInt(5, parent.intValue() ); }
                                                                        ns.execute();
                                                                        ns.clearParameters();
                                                                        Integer nodeId = new Integer(db.getInt(" select max(id) from hillockPathNodes; "));

                                                                        // Put any of this nodes children on the stack, at the start, so
                                                                        // they are inserted first.
                                                                        LinkedList children = (LinkedList) node.get("children");
                                                                        if (children != null) {
                                                                                LinkedList stackAdd = new LinkedList();
                                                                                for (Iterator j = children.iterator(); j.hasNext(); ) {
                                                                                        Map child = (Map) j.next();
                                                                                        child.put("parent", nodeId);
                                                                                        stackAdd.add(child);
                                                                                }
                                                                                stack.addAll(0, stackAdd);
                                                                        }
                                                                }
                                                        }
                                                }
                                                catch (Exception e) {
                                                        logger.throwing("HillockWorker","run",e);
                                                }
                                                finally {
                                                        try { if (db != null) { db.commit(); } } catch (Exception e) { logger.throwing("HillockWorker","run",e); }
                                                        try { if (db != null) { db.close(); } } catch (Exception e) { logger.throwing("HillockWorker","run",e); }
                                                }
                                                workList.clear();
                                        }
                                }
                                catch (Exception e) {
                                        enabled = false;
                                        logger.throwing("HillockWorker","run",e);
                                }
                        }
                };
                worker.start();
        } // static worker initialization
}

---