zookeeper(2) 文件系统

　　这一节我们主要来看一下zookeeper文件系统的实现。

树结构

　　为了提高对指定节点的操作，zookeeper使用一个HashMap来存储树结构数据,key为数据路径，value为节点数据。

树节点（DataNode）

 public class DataNode implements Record {
     //父节点
     DataNode parent;
     //节点数据
     byte data[];
     //节点权限
     Long acl;
     //节点状态信息
     public StatPersisted stat;
     //子节点名
     private Set<String> children = null;

 }

数节点状态（StatPersisted）

 public class StatPersisted implements Record {
   //该节点创建是的事务xid
   private long czxid;
   //该节点最后一次修改的事务id
   private long mzxid;
   //创建时间
   private long ctime;
   //最后一次修改时间
   private long mtime;
   //节点版本号
   private int version;
   //子节点版本号
   private int cversion;
   //acl版本号
   private int aversion;
   //是否为零时节点
   private long ephemeralOwner;
   //子列表被修改的zxid
   private long pzxid;
 }

配额管理

　　zookeeper在创建、修改节点时可以设置特定路径上的配额。在实现上，配额也存储在文件系统中，并且还存储了节点当前的信息。配额的控制在特定的路径下：/zookeeper/quota/{节点路径}/zookeeper_limits 节点的限制数据节点；/zookeeper/quota/{节点路径}/zookeeper_stats  节点的当前量节点。一个节点路径中只能有一个配额限制。

　　当在对某个节点进行操作时，我们需要知道该路径下的哪个节点设置了配额，因为树结构使用hashmap来存储，所以不便于通过路径查找，所以使用了一个树结构来表示那个节点上配置了限额。

配额路径（PathTrie）

 public class PathTrie {
     //根节点
     private final TrieNode rootNode ;
     //节点
     static class TrieNode {
         //是否设置配额，false没有，true有
         boolean property = false;
         //子节点
         final HashMap<String, TrieNode> children;
         //父节点
         TrieNode parent = null;

         //删除子节点配额
         void deleteChild(String childName) {
             synchronized(children) {
                 if (!children.containsKey(childName)) {
                     return;
                 }
                 TrieNode childNode = children.get(childName);
                 //如果子节点没有自己点直接删除，否则设置property为false
                 if (childNode.getChildren().length == 1) {
                     childNode.setParent(null);
                     children.remove(childName);
                 }
                 else {
                     childNode.setProperty(false);
                 }
             }
         }
     }
     //新增配额节点
     public void addPath(String path) {
         if (path == null) {
             return;
         }
         String[] pathComponents = path.split("/");
         TrieNode parent = rootNode;
         String part = null;
         if (pathComponents.length <= 1) {
             throw new IllegalArgumentException("Invalid path " + path);
         }
         for (int i=1; i<pathComponents.length; i++) {
             part = pathComponents[i];
             if (parent.getChild(part) == null) {
                 parent.addChild(part, new TrieNode(parent));
             }
             parent = parent.getChild(part);
         }
         parent.setProperty(true);
     }

     //删除配额节点
     public void deletePath(String path) {
         if (path == null) {
             return;
         }
         String[] pathComponents = path.split("/");
         TrieNode parent = rootNode;
         String part = null;
         if (pathComponents.length <= 1) {
             throw new IllegalArgumentException("Invalid path " + path);
         }
         for (int i=1; i<pathComponents.length; i++) {
             part = pathComponents[i];
             if (parent.getChild(part) == null) {
                 return;
             }
             parent = parent.getChild(part);
         }
         TrieNode realParent  = parent.getParent();
         realParent.deleteChild(part);
     }

     //获取指定路径上配额节点最大路径
     public String findMaxPrefix(String path) {
         if (path == null) {
             return null;
         }
         if ("/".equals(path)) {
             return path;
         }
         String[] pathComponents = path.split("/");
         TrieNode parent = rootNode;
         List<String> components = new ArrayList<String>();
         if (pathComponents.length <= 1) {
             throw new IllegalArgumentException("Invalid path " + path);
         }
         int i = 1;
         String part = null;
         StringBuilder sb = new StringBuilder();
         //最大路径的index
         int lastindex = -1;
         while((i < pathComponents.length)) {
             if (parent.getChild(pathComponents[i]) != null) {
                 part = pathComponents[i];
                 parent = parent.getChild(part);
                 components.add(part);
                 if (parent.getProperty()) {
                     lastindex = i-1;
                 }
             }
             else {
                 break;
             }
             i++;
         }
         for (int j=0; j< (lastindex+1); j++) {
             sb.append("/" + components.get(j));
         }
         return sb.toString();
     }
 }

监听器管理

　　zookeeper可以对指定路径进行监听，当指定路径发生变化时，监听器会执行响应的动作。主要是通过将path和watcher建立关联关系，在对指定路径进行操作是调用相应监听器方法。

监听管理器（WatchManager）

 public class WatchManager {
     //key为path value为该path对应的watcher集合
     private final HashMap<String, HashSet<Watcher>> watchTable =
         new HashMap<String, HashSet<Watcher>>();
     //key为watcher value为该watcher对应的path集合，使用两个hashmap来维护路径和监听器是因为watcher和路径是多对多关系，这样无论通过watcher还是路径都可以很快找到对应的路径和watcher。
     private final HashMap<Watcher, HashSet<String>> watch2Paths =
         new HashMap<Watcher, HashSet<String>>();

     public synchronized void addWatch(String path, Watcher watcher) {
         //新增watcher到watchTable
         HashSet<Watcher> list = watchTable.get(path);
         if (list == null) {
             list = new HashSet<Watcher>(4);
             watchTable.put(path, list);
         }
         list.add(watcher);
         //新增watcher到watch2Paths
         HashSet<String> paths = watch2Paths.get(watcher);
         if (paths == null) {
             paths = new HashSet<String>();
             watch2Paths.put(watcher, paths);
         }
         paths.add(path);
     }

     public synchronized void removeWatcher(Watcher watcher) {
         //从watch2Paths和watchTable删除watcher
         HashSet<String> paths = watch2Paths.remove(watcher);
         if (paths == null) {
             return;
         }
         for (String p : paths) {
             HashSet<Watcher> list = watchTable.get(p);
             if (list != null) {
                 list.remove(watcher);
                 if (list.size() == 0) {
                     watchTable.remove(p);
                 }
             }
         }
     }
     //触发watcher
     public Set<Watcher> triggerWatch(String path, EventType type, Set<Watcher> supress) {
         WatchedEvent e = new WatchedEvent(type,
                 KeeperState.SyncConnected, path);
         HashSet<Watcher> watchers;
         synchronized (this) {
             //zookeeper的通知是一次性的，也就是说如果一个路径触发通知后，相应的watcher会从这两个hashmap中删除。
             watchers = watchTable.remove(path);
             for (Watcher w : watchers) {
                 HashSet<String> paths = watch2Paths.get(w);
                 if (paths != null) {
                     paths.remove(path);
                 }
             }
         }
         for (Watcher w : watchers) {
             if (supress != null && supress.contains(w)) {
                 continue;
             }
             w.process(e);
         }
         return watchers;
     }
 }

临时节点

　　zookeeper中有一类节点在创建的session结束后会被清除掉，zookeeper在创建这些节点时会记录节点和session 的对应关系，到session结束是，删除这些节点。

结束session（DataTree.killSession）

 //session与零时节点对应关系
 private final Map<Long, HashSet<String>> ephemerals =
         new ConcurrentHashMap<Long, HashSet<String>>();
 //关闭session
 void killSession(long session, long zxid) {
         //session结束后，删除零时节点
         HashSet<String> list = ephemerals.remove(session);
         if (list != null) {
             for (String path : list) {
                 try {
                     deleteNode(path, zxid);
                 } catch (NoNodeException e) {
                     LOG.warn("Ignoring NoNodeException for path " + path
                             + " while removing ephemeral for dead session 0x"
                             + Long.toHexString(session));
                 }
             }
         }
     }

权限管理

　　zookeeper的每个节点都会存储该节点可以访问的用户已经可以执行的操作。

权限（ACL）

 public class ACL implements Record {
   //perms即权限，有五种权限：READ（可读）；WRITE（可写）;CREATE（可创建子节点）;DELETE（可删除子节点）;ADMIN（管理权限）;perms的每一位代表一种权限。
   private int perms;
   //id是授权的对象。
   private org.apache.zookeeper.data.Id id;
 }
 public class Id implements Record {
   //scheme是权限模式，有五种模式：digest（通过用户名密码，id为user:password）；auth（）；ip（通过ip，id为ip地址）；world（固定用户为anyone，为所有Client端开放权限 ）；super（对应的id拥有超级权限）。
   private String scheme;
   private String id;
 }

每个节点可以设置多个权限，实际节点权限只存储一个整数，对应的acl信息保存在两个hashmap中。（DataTree.java)

 public final Map<Long, List<ACL>> longKeyMap = new HashMap<Long, List<ACL>>();
 public final Map<List<ACL>, Long> aclKeyMap = new HashMap<List<ACL>, Long>();

节点操作