/* $Id$ */

/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.manifoldcf.core.lockmanager;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.manifoldcf.core.interfaces.ManifoldCFException;
import org.apache.manifoldcf.core.system.ManifoldCF;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

/** An instance of this class is the Zookeeper analog to a database connection.
* Basically, it bundles up the Zookeeper functionality we need in a nice package,
* which we can share between users as needed.  These connections will be pooled,
* and will be closed when the process they live in is shut down.
*/
public class ZooKeeperConnection
{
  public static final String _rcsid = "@(#)$Id$";

  private static final String READ_PREFIX = "read-";
  private static final String NONEXWRITE_PREFIX = "nonexwrite-";
  private static final String WRITE_PREFIX = "write-";

  private static final String CHILD_PREFIX = "child-";
  
  protected final String connectString;
  protected final int sessionTimeout;
  
  // Our zookeeper client
  protected ZooKeeper zookeeper = null;
  protected ZooKeeperWatcher zookeeperWatcher = null;

  // Transient state
  protected String lockNode = null;
  protected String nodePath = null;
  protected byte[] nodeData = null;

  /** Constructor. */
  public ZooKeeperConnection(String connectString, int sessionTimeout)
    throws ManifoldCFException, InterruptedException
  {
    this.connectString = connectString;
    this.sessionTimeout = sessionTimeout;
    zookeeperWatcher = new ZooKeeperWatcher();
    createSession();
  }
  
  protected void createSession()
    throws ManifoldCFException, InterruptedException
  {
    try
    {
      zookeeper = new ZooKeeper(connectString, sessionTimeout, zookeeperWatcher);
    }
    catch (InterruptedIOException e)
    {
      throw new InterruptedException(e.getMessage());
    }
    catch (IOException e)
    {
      throw new ManifoldCFException("Zookeeper initialization error: "+e.getMessage(),e);
    }
  }

  /** Create a transient node.
  */
  public void createNode(String nodePath, byte[] nodeData)
    throws ManifoldCFException, InterruptedException
  {
    if (this.nodePath != null)
      throw new IllegalStateException("Ephemeral node '"+this.nodePath+"' already open; can't open '"+nodePath+"'.");

    while (true)
    {
      try
      {
        if (this.nodePath == null)
        {
          zookeeper.create(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
          // Keep a record of the ephemeral node
          this.nodePath = nodePath;
          this.nodeData = nodeData;
        }
        break;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,false);
      }
    }
  }
  
  /** Check whether a node exists.
  *@param nodePath is the path of the node.
  *@return the data, if the node if exists, otherwise null.
  */
  public boolean checkNodeExists(String nodePath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        return (zookeeper.exists(nodePath,false) != null);
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }

  /** Get node data.
  *@param nodePath is the path of the node.
  *@return the data, if the node if exists, otherwise null.
  */
  public byte[] getNodeData(String nodePath)
    throws ManifoldCFException, InterruptedException
  {
    return readData(nodePath);
  }
  
  /** Set node data.
  */
  public void setNodeData(byte[] data)
    throws ManifoldCFException, InterruptedException
  {
    if (nodePath == null)
      throw new IllegalStateException("Can't set data for a node path we did not create: '"+nodePath+"'");
    writeData(nodePath, data);
    this.nodeData = data;
  }
  
  /** Delete a node.
  */
  public void deleteNode()
    throws ManifoldCFException, InterruptedException
  {
    if (nodePath == null)
      throw new IllegalStateException("Can't delete ephemeral node that isn't registered: '"+nodePath+"'");
    while (true)
    {
      try
      {
        if (nodePath != null)
        {
          zookeeper.delete(nodePath,-1);
          nodePath = null;
          nodeData = null;
        }
        return;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,false);
      }
    }
  }
  
  /** Delete all a node's children.
  */
  public void deleteNodeChildren(String nodePath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        List<String> children = zookeeper.getChildren(nodePath,false);
        for (String child : children)
        {
          zookeeper.delete(nodePath + "/" + child,-1);
        }
        break;
      }
      catch (KeeperException.NoNodeException e)
      {
        break;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  /** Get the relative paths of all node's children.  If the node does not exist,
  * return an empty list.
  */
  public List<String> getChildren(String nodePath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        //System.out.println("Children of '"+nodePath+"':");
        List<String> children = zookeeper.getChildren(nodePath,false);
        List<String> rval = new ArrayList<String>();
        for (String child : children)
        {
          //System.out.println(" '"+child+"'");
          if (child.startsWith(CHILD_PREFIX))
            rval.add(child.substring(CHILD_PREFIX.length()));
        }
        return rval;
      }
      catch (KeeperException.NoNodeException e)
      {
        return new ArrayList<String>();
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  /** Create a persistent child of a node.
  */
  public void createChild(String nodePath, String childName)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        //System.out.println("Creating child '"+childName+"' of nodepath '"+nodePath+"'");
        createPersistentPath(nodePath + "/" + CHILD_PREFIX + childName, null);
        break;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }

  protected void createPersistentPath(String path, byte[] data)
    throws KeeperException, InterruptedException
  {
    // Loop until we've created the entire path, but initially try the whole thing for performance
    while (true)
    {
      try
      {
        zookeeper.create(path, data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        // Break on success
        break;
      }
      catch (KeeperException.NoNodeException e)
      {
        // Strip off last part of path, and try recursively
        int lastIndex = path.lastIndexOf("/");
        // No last path: rethrow because we don't have a clue what is going on
        if (lastIndex == -1 || lastIndex == 0)
          throw e;
        createPersistentPath(path.substring(0,lastIndex),null);
        // Retry
      }
      catch (KeeperException.NodeExistsException e)
      {
        // Path is there: someone else beat us to it
        // But we do have to set the data.
        // NOTE: This code relies on the fact that only leaf persistent nodes have data.
        if (data != null)
        {
          try
          {
            zookeeper.setData(path, data, -1);
          }
          catch (KeeperException.NoNodeException e2)
          {
            // Repeat, since we've lost our node
            continue;
          }
        }
        break;
      }
    }
  }
  
  /** Delete the child of a node.
  */
  public void deleteChild(String nodePath, String childName)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        //System.out.println("Deleting child '"+childName+"' of nodePath '"+nodePath+"'");
        zookeeper.delete(nodePath + "/" + CHILD_PREFIX + childName, -1);
        //System.out.println("...done");
        break;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  /** Obtain a write lock, with no wait.
  *@param lockPath is the lock node path.
  *@return true if the lock was obtained, false otherwise.
  */
  public boolean obtainWriteLockNoWait(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also write lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a write lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,WRITE_PREFIX);
        String lockSequenceNumber = lockNode.substring(lockPath.length() + 1 + WRITE_PREFIX.length());
        // See if we got it
        List<String> children = zookeeper.getChildren(lockPath,false);
        for (String x : children)
        {
          String otherLock;
          if (x.startsWith(WRITE_PREFIX))
            otherLock = x.substring(WRITE_PREFIX.length());
          else if (x.startsWith(NONEXWRITE_PREFIX))
            otherLock = x.substring(NONEXWRITE_PREFIX.length());
          else if (x.startsWith(READ_PREFIX))
            otherLock = x.substring(READ_PREFIX.length());
          else
            continue;
          if (otherLock.compareTo(lockSequenceNumber) < 0)
          {
            // We didn't get the lock.  Clean up and exit
            releaseLock();
            return false;
          }
        }
        // We got it!
        return true;
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }
  
  /** Obtain a write lock, with wait.
  *@param lockPath is the lock node path.
  */
  public void obtainWriteLock(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also write lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a write lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,WRITE_PREFIX);
        long lockSequenceNumber = new Long(lockNode.substring(lockPath.length() + 1 + WRITE_PREFIX.length())).longValue();
        //System.out.println("Trying to get write lock for '"+lockSequenceNumber+"'");
        while (true)
        {
          //System.out.println("Assessing whether we got lock for '"+lockNode+"'...");
          // See if we got it
          List<String> children = zookeeper.getChildren(lockPath,false);
          String previousLock = null;
          boolean gotLock = true;
          long highestPreviousLockIndex = -1L;
          for (String x : children)
          {
            String otherLock;
            if (x.startsWith(WRITE_PREFIX))
              otherLock = x.substring(WRITE_PREFIX.length());
            else if (x.startsWith(NONEXWRITE_PREFIX))
              otherLock = x.substring(NONEXWRITE_PREFIX.length());
            else if (x.startsWith(READ_PREFIX))
              otherLock = x.substring(READ_PREFIX.length());
            else
              continue;
            long otherLockSequenceNumber = new Long(otherLock).longValue();
            //System.out.println("Saw other child sequence number "+otherLockSequenceNumber);
            if (otherLockSequenceNumber < lockSequenceNumber)
            {
              // We didn't get the lock.  But keep going because we're looking for the node right before the
              // one we just asserted.
              gotLock = false;
              if (otherLockSequenceNumber > highestPreviousLockIndex)
              {
                previousLock = x;
                highestPreviousLockIndex = otherLockSequenceNumber;
              }
            }
          }

          if (gotLock)
          {
            // We got it!
            //System.out.println("Got write lock for '"+lockSequenceNumber+"'");
            return;
          }

          // There SHOULD be a previous node immediately prior to the one we asserted.  If we didn't find one, go back around;
          // the previous lock was probably created and destroyed before we managed to get the children.
          if (previousLock != null)
          {
            //System.out.println(" Waiting on '"+previousLock+"' for write lock '"+lockSequenceNumber+"'");
            // Create an exists() watch on the previous node, and wait until we are awakened by that watch firing.
            ExistsWatcher w = new ExistsWatcher();
            Stat s = zookeeper.exists(lockPath+"/"+previousLock, w);
            if (s != null)
              w.waitForEvent();
          }
          //else
          //  System.out.println(" Retrying for write lock '"+lockSequenceNumber+"'");
        }
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }

  /** Obtain a non-ex-write lock, with no wait.
  *@param lockPath is the lock node path.
  *@return true if the lock was obtained, false otherwise.
  */
  public boolean obtainNonExWriteLockNoWait(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also non-ex write lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a read lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,NONEXWRITE_PREFIX);
        String lockSequenceNumber = lockNode.substring(lockPath.length() + 1 + NONEXWRITE_PREFIX.length());
        // See if we got it
        List<String> children = null;
        while (true)
        {
          try
          {
            children = zookeeper.getChildren(lockPath,false);
            break;
          }
          catch (KeeperException.NoNodeException e)
          {
            // New session; back around again.
            break;
          }
          catch (KeeperException e)
          {
            handleKeeperException(e,true);
          }
        }
        if (children == null)
        {
          // Reassert ephemeral node b/c we had a session restart
          continue;
        }
        for (String x : children)
        {
          String otherLock;
          if (x.startsWith(WRITE_PREFIX))
            otherLock = x.substring(WRITE_PREFIX.length());
          else if (x.startsWith(READ_PREFIX))
            otherLock = x.substring(READ_PREFIX.length());
          else
            continue;
          if (otherLock.compareTo(lockSequenceNumber) < 0)
          {
            // We didn't get the lock.  Clean up and exit
            releaseLock();
            return false;
          }
        }
        // We got it!
        return true;
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }

  /** Obtain a non-ex-write lock, with wait.
  *@param lockPath is the lock node path.
  */
  public void obtainNonExWriteLock(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also non-ex write lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a read lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,NONEXWRITE_PREFIX);
        long lockSequenceNumber = new Long(lockNode.substring(lockPath.length() + 1 + NONEXWRITE_PREFIX.length())).longValue();
        while (true)
        {
          // See if we got it
          List<String> children = null;
          while (true)
          {
            try
            {
              children = zookeeper.getChildren(lockPath,false);
              break;
            }
            catch (KeeperException.NoNodeException e)
            {
              break;
            }
            catch (KeeperException e)
            {
              handleKeeperException(e,true);
            }
          }

          if (children == null)
            break;

          String previousLock = null;
          boolean gotLock = true;
          long highestPreviousLockIndex = -1L;
          for (String x : children)
          {
            String otherLock;
            if (x.startsWith(WRITE_PREFIX))
              otherLock = x.substring(WRITE_PREFIX.length());
            else if (x.startsWith(READ_PREFIX))
              otherLock = x.substring(READ_PREFIX.length());
            else
              continue;
            long otherLockSequenceNumber = new Long(otherLock).longValue();
            //System.out.println("Saw other child sequence number "+otherLockSequenceNumber);
            if (otherLockSequenceNumber < lockSequenceNumber)
            {
              // We didn't get the lock.  But keep going because we're looking for the node right before the
              // one we just asserted.
              gotLock = false;
              if (otherLockSequenceNumber > highestPreviousLockIndex)
              {
                previousLock = x;
                highestPreviousLockIndex = otherLockSequenceNumber;
              }
            }
          }
            
          if (gotLock)
          {
            // We got it!
            return;
          }

          // There SHOULD be a previous node immediately prior to the one we asserted.  If we didn't find one, go back around;
          // the previous lock was probably created and destroyed before we managed to get the children.
          if (previousLock != null)
          {
            // Create an exists() watch on the previous node, and wait until we are awakened by that watch firing.
            ExistsWatcher w = new ExistsWatcher();
            Stat s = zookeeper.exists(lockPath+"/"+previousLock, w);
            if (s != null)
              w.waitForEvent();
          }
        }
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }

  /** Obtain a read lock, with no wait.
  *@param lockPath is the lock node path.
  *@return true if the lock was obtained, false otherwise.
  */
  public boolean obtainReadLockNoWait(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also read lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a read lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,READ_PREFIX);
        String lockSequenceNumber = lockNode.substring(lockPath.length() + 1 + READ_PREFIX.length());
        // See if we got it
        List<String> children = null;
        while (true)
        {
          try
          {
            children = zookeeper.getChildren(lockPath,false);
            break;
          }
          catch (KeeperException.NoNodeException e)
          {
            break;
          }
          catch (KeeperException e)
          {
            handleKeeperException(e,true);
          }
        }
        if (children == null)
          continue;
        for (String x : children)
        {
          String otherLock;
          if (x.startsWith(WRITE_PREFIX))
            otherLock = x.substring(WRITE_PREFIX.length());
          else if (x.startsWith(NONEXWRITE_PREFIX))
            otherLock = x.substring(NONEXWRITE_PREFIX.length());
          else
            continue;
          if (otherLock.compareTo(lockSequenceNumber) < 0)
          {
            // We didn't get the lock.  Clean up and exit
            releaseLock();
            return false;
          }
        }
        // We got it!
        return true;
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }
  
  /** Obtain a read lock, with wait.
  *@param lockPath is the lock node path.
  */
  public void obtainReadLock(String lockPath)
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Already have a lock in place: '"+lockNode+"'; can't also read lock '"+lockPath+"'");

    while (true)
    {
      try
      {
        // Assert that we want a read lock
        if (lockNode == null)
          lockNode = createSequentialChild(lockPath,READ_PREFIX);
        long lockSequenceNumber = new Long(lockNode.substring(lockPath.length() + 1 + READ_PREFIX.length())).longValue();
        //System.out.println("Trying to get read lock for '"+lockSequenceNumber+"'");
        while (true)
        {
          // See if we got it
          List<String> children = null;
          while (true)
          {
            try
            {
              children = zookeeper.getChildren(lockPath,false);
              break;
            }
            catch (KeeperException.NoNodeException e)
            {
              break;
            }
            catch (KeeperException e)
            {
              handleKeeperException(e,true);
            }
          }

          // Handle new session
          if (children == null)
            break;
            
          String previousLock = null;
          boolean gotLock = true;
          long highestPreviousLockIndex = -1L;
          for (String x : children)
          {
            String otherLock;
            if (x.startsWith(WRITE_PREFIX))
              otherLock = x.substring(WRITE_PREFIX.length());
            else if (x.startsWith(NONEXWRITE_PREFIX))
              otherLock = x.substring(NONEXWRITE_PREFIX.length());
            else
              continue;
            long otherLockSequenceNumber = new Long(otherLock).longValue();
            //System.out.println("Saw other child sequence number "+otherLockSequenceNumber);
            if (otherLockSequenceNumber < lockSequenceNumber)
            {
              // We didn't get the lock.  But keep going because we're looking for the node right before the
              // one we just asserted.
              gotLock = false;
              if (otherLockSequenceNumber > highestPreviousLockIndex)
              {
                previousLock = x;
                highestPreviousLockIndex = otherLockSequenceNumber;
              }
            }
          }
            
          if (gotLock)
          {
            // We got it!
            //System.out.println("Got read lock for '"+lockSequenceNumber+"'");
            return;
          }

          // There SHOULD be a previous node immediately prior to the one we asserted.  If we didn't find one, go back around;
          // the previous lock was probably created and destroyed before we managed to get the children.
          if (previousLock != null)
          {
            //System.out.println(" Waiting on '"+previousLock+"' for read lock '"+lockSequenceNumber+"'");
            // Create an exists() watch on the previous node, and wait until we are awakened by that watch firing.
            ExistsWatcher w = new ExistsWatcher();
            Stat s = zookeeper.exists(lockPath+"/"+previousLock, w);
            if (s != null)
              w.waitForEvent();
          }
          //else
          //  System.out.println(" Retrying for read lock '"+lockSequenceNumber+"'");

        }
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }
  
  /** Release the (saved) lock.
  */
  public void releaseLock()
    throws ManifoldCFException, InterruptedException
  {
    if (lockNode == null)
      throw new IllegalStateException("Can't release lock we don't hold");
    //System.out.println("Releasing lock '"+lockNode+"'");
    
    while (true)
    {
      if (lockNode == null)
        break;
      try
      {
        zookeeper.delete(lockNode,-1);
        lockNode = null;
        break;
      }
      catch (InterruptedException e)
      {
        lockNode = null;
        throw e;
      }
      catch (KeeperException e)
      {
        handleEphemeralNodeKeeperException(e,true);
      }
    }
  }

  public byte[] readData(String resourcePath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        return zookeeper.getData(resourcePath,false,null);
      }
      catch (KeeperException.NoNodeException e)
      {
        return null;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  public void writeData(String resourcePath, byte[] data)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        if (data == null)
        {
          try
          {
            zookeeper.delete(resourcePath, -1);
          }
          catch (KeeperException.NoNodeException e)
          {
          }
          break;
        }
        else
        {
          try
          {
            zookeeper.setData(resourcePath, data, -1);
          }
          catch (KeeperException.NoNodeException e)
          {
            createPersistentPath(resourcePath, data);
          }
          break;
        }
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }

  public void setGlobalFlag(String flagPath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        createPersistentPath(flagPath, null);
        break;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }

  public void clearGlobalFlag(String flagPath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        try
        {
          zookeeper.delete(flagPath,-1);
        }
        catch (KeeperException.NoNodeException e)
        {
        }
        break;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  public boolean checkGlobalFlag(String flagPath)
    throws ManifoldCFException, InterruptedException
  {
    while (true)
    {
      try
      {
        Stat s = zookeeper.exists(flagPath,false);
        return s != null;
      }
      catch (KeeperException e)
      {
        handleKeeperException(e,true);
      }
    }
  }
  
  /** Close this connection. */
  public void close()
    throws InterruptedException
  {
    if (lockNode != null)
      throw new IllegalStateException("Should not be closing handles that have open locks!  Locknode: '"+lockNode+"'");
    zookeeper.close();
    zookeeper = null;
    zookeeperWatcher = null;
  }
  
  /** Handle keeper exceptions that may involve ephemeral node creation.
  */
  protected void handleEphemeralNodeKeeperException(KeeperException e, boolean recreate)
    throws ManifoldCFException, InterruptedException
  {
    if (e instanceof KeeperException.ConnectionLossException || e instanceof KeeperException.SessionExpiredException)
    {
      while (true)
      {
        try
        {
          // Close the handle, open a new one
          lockNode = null;
          if (!recreate)
          {
            nodePath = null;
            nodeData = null;
          }
          zookeeper.close();
          createSession();
          // Lock is lost, but we can (and should) recreate the ephemeral nodes
          if (nodePath != null)
          {
            zookeeper.create(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
          }
          break;
        }
        catch (KeeperException e2)
        {
          if (!(e2 instanceof KeeperException.ConnectionLossException) && !(e2 instanceof KeeperException.SessionExpiredException))
            throw new ManifoldCFException(e2.getMessage(),e2);
        }
      }
    }
    else
    {
      // If nothing we know how to deal with, throw.
      throw new ManifoldCFException(e.getMessage(),e);
    }
  }

  /** Handle keeper exceptions that don't involve ephemeral node creation.
  */
  protected void handleKeeperException(KeeperException e, boolean recreate)
    throws ManifoldCFException, InterruptedException
  {
    if (e instanceof KeeperException.ConnectionLossException)
    {
      // Retry if connection loss
      ManifoldCF.sleep(100L);
    }
    else if (e instanceof KeeperException.SessionExpiredException)
    {
      while (true)
      {
        try
        {
          // Close the handle, open a new one
          lockNode = null;
          if (!recreate)
          {
            nodePath = null;
            nodeData = null;
          }
          zookeeper.close();
          createSession();
          // Lock is lost, but we can (and should) recreate the ephemeral nodes
          if (nodePath != null)
          {
            zookeeper.create(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
          }
          break;
        }
        catch (KeeperException e2)
        {
          if (!(e2 instanceof KeeperException.ConnectionLossException) && !(e2 instanceof KeeperException.SessionExpiredException))
            throw new ManifoldCFException(e2.getMessage(),e2);
        }
      }
    }
    else
    {
      // If nothing we know how to deal with, throw.
      throw new ManifoldCFException(e.getMessage(),e);
    }
  }
  
  public static String zooKeeperSafeName(String input)
  {
    // Escape "/" characters
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < input.length(); i++)
    {
      char x = input.charAt(i);
      if (x == '/')
        sb.append('\\').append('0');
      else if (x == '\u007f')
        sb.append('\\').append('1');
      else if (x == '\\')
        sb.append('\\').append('\\');
      else if (x >= '\u0000' && x < '\u0020')
        sb.append('\\').append(x + '\u0040');
      else if (x >= '\u0080' && x < '\u00a0')
        sb.append('\\').append(x + '\u0060' - '\u0080');
      else
        sb.append(x);
    }
    return sb.toString();
  }

  public static String zooKeeperDecodeSafeName(String input)
  {
    // Escape "/" characters
    StringBuilder sb = new StringBuilder();
    int i = 0;
    while (i < input.length())
    {
      char x = input.charAt(i);
      if (x == '\\')
      {
        i++;
        if (i == input.length())
          throw new RuntimeException("Supposedly safe zookeeper name is not properly encoded!!");
        x = input.charAt(i);
        if (x == '0')
          sb.append('/');
        else if (x == '1')
          sb.append('\u007f');
        else if (x == '\\')
          sb.append('\\');
        else if (x >= '\u0040' && x < '\u0060')
          sb.append(x - '\u0040');
        else if (x >= '\u0060' && x < '\u0080')
          sb.append(x - '\u0060' + '\u0080');
        else
          throw new RuntimeException("Supposedly safe zookeeper name is not properly encoded!!");
      }
      else
        sb.append(x);
      i++;
    }
    return sb.toString();
  }

  // Protected methods
  
  /** Create a node and a sequential child node.  Neither node has any data.
  */
  protected String createSequentialChild(String mainNode, String childPrefix)
    throws KeeperException, InterruptedException
  {
    // Because zookeeper is so slow, AND reports all exceptions to the log, we do the minimum.
    while (true)
    {
      try
      {
        return zookeeper.create(mainNode + "/" + childPrefix, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
      }
      catch (KeeperException.NoNodeException e)
      {
        try
        {
          zookeeper.create(mainNode, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
        catch (KeeperException.NodeExistsException e2)
        {
        }
      }
    }
  }

  /** Watcher class for zookeeper, so we get notified about zookeeper events. */
  protected static class ZooKeeperWatcher implements Watcher
  {
    public ZooKeeperWatcher()
    {
    }
    
    @Override
    public void process(WatchedEvent event)
    {
    }

  }

  /** Watcher class for exists state changes, so we get notified about deletions of lock request nodes. */
  protected static class ExistsWatcher implements Watcher
  {
    protected boolean eventTriggered = false;

    public ExistsWatcher()
    {
    }
    
    @Override
    public void process(WatchedEvent event)
    {
      synchronized (this)
      {
        eventTriggered = true;
        notifyAll();
      }
    }

    public void waitForEvent()
      throws InterruptedException
    {
      synchronized (this)
      {
        if (eventTriggered)
          return;
        wait();
      }
    }
    
  }

}
