zookeeper源码之服务端数据管理(代码片段)

 1 public class DataNode implements Record 
 2     //父节点
 3     DataNode parent;
 4     //节点数据
 5     byte data[];
 6     //节点权限
 7     Long acl;
 8     //节点状态信息
 9     public StatPersisted stat;
10     //子节点名
11     private Set<String> children = null;
12 
13 

 1 public class StatPersisted implements Record 
 2   //该节点创建是的事务xid
 3   private long czxid;
 4   //该节点最后一次修改的事务id
 5   private long mzxid;
 6   //创建时间
 7   private long ctime;
 8   //最后一次修改时间
 9   private long mtime;
10   //节点版本号
11   private int version;
12   //子节点版本号
13   private int cversion;
14   //acl版本号
15   private int aversion;
16   //是否为零时节点
17   private long ephemeralOwner;
18   //子列表被修改的zxid
19   private long pzxid;
20 

  1 public class PathTrie 
  2     //根节点
  3     private final TrieNode rootNode ;
  4     //节点
  5     static class TrieNode 
  6         //是否设置配额，false没有，true有
  7         boolean property = false;
  8         //子节点
  9         final HashMap<String, TrieNode> children;
 10         //父节点
 11         TrieNode parent = null;
 12         
 13      
 14         //删除子节点配额
 15         void deleteChild(String childName) 
 16             synchronized(children) 
 17                 if (!children.containsKey(childName)) 
 18                     return;
 19                 
 20                 TrieNode childNode = children.get(childName);
 21                 //如果子节点没有自己点直接删除，否则设置property为false
 22                 if (childNode.getChildren().length == 1)  
 23                     childNode.setParent(null);
 24                     children.remove(childName);
 25                 
 26                 else 
 27                     childNode.setProperty(false);
 28                 
 29             
 30         
 31     
 32     //新增配额节点
 33     public void addPath(String path) 
 34         if (path == null) 
 35             return;
 36         
 37         String[] pathComponents = path.split("/");
 38         TrieNode parent = rootNode;
 39         String part = null;
 40         if (pathComponents.length <= 1) 
 41             throw new IllegalArgumentException("Invalid path " + path);
 42         
 43         for (int i=1; i<pathComponents.length; i++) 
 44             part = pathComponents[i];
 45             if (parent.getChild(part) == null) 
 46                 parent.addChild(part, new TrieNode(parent));
 47             
 48             parent = parent.getChild(part);
 49         
 50         parent.setProperty(true);
 51     
 52     
 53     //删除配额节点
 54     public void deletePath(String path) 
 55         if (path == null) 
 56             return;
 57         
 58         String[] pathComponents = path.split("/");
 59         TrieNode parent = rootNode;
 60         String part = null;
 61         if (pathComponents.length <= 1)  
 62             throw new IllegalArgumentException("Invalid path " + path);
 63         
 64         for (int i=1; i<pathComponents.length; i++) 
 65             part = pathComponents[i];
 66             if (parent.getChild(part) == null) 
 67                 return;
 68             
 69             parent = parent.getChild(part);
 70         
 71         TrieNode realParent  = parent.getParent();
 72         realParent.deleteChild(part);
 73     
 74     
 75     //获取指定路径上配额节点最大路径
 76     public String findMaxPrefix(String path) 
 77         if (path == null) 
 78             return null;
 79         
 80         if ("/".equals(path)) 
 81             return path;
 82         
 83         String[] pathComponents = path.split("/");
 84         TrieNode parent = rootNode;
 85         List<String> components = new ArrayList<String>();
 86         if (pathComponents.length <= 1) 
 87             throw new IllegalArgumentException("Invalid path " + path);
 88         
 89         int i = 1;
 90         String part = null;
 91         StringBuilder sb = new StringBuilder();
 92         //最大路径的index
 93         int lastindex = -1;
 94         while((i < pathComponents.length)) 
 95             if (parent.getChild(pathComponents[i]) != null) 
 96                 part = pathComponents[i];
 97                 parent = parent.getChild(part);
 98                 components.add(part);
 99                 if (parent.getProperty()) 
100                     lastindex = i-1;
101                 
102             
103             else 
104                 break;
105             
106             i++;
107         
108         for (int j=0; j< (lastindex+1); j++) 
109             sb.append("/" + components.get(j));
110         
111         return sb.toString();
112     
113 

 1 public class WatchManager 
 2     //key为path value为该path对应的watcher集合
 3     private final HashMap<String, HashSet<Watcher>> watchTable =
 4         new HashMap<String, HashSet<Watcher>>();
 5     //key为watcher value为该watcher对应的path集合，使用两个hashmap来维护路径和监听器是因为watcher和路径是多对多关系，这样无论通过watcher还是路径都可以很快找到对应的路径和watcher。
 6     private final HashMap<Watcher, HashSet<String>> watch2Paths =
 7         new HashMap<Watcher, HashSet<String>>();
 8     
 9     public synchronized void addWatch(String path, Watcher watcher) 
10         //新增watcher到watchTable
11         HashSet<Watcher> list = watchTable.get(path);
12         if (list == null) 
13             list = new HashSet<Watcher>(4);
14             watchTable.put(path, list);
15         
16         list.add(watcher);
17         //新增watcher到watch2Paths
18         HashSet<String> paths = watch2Paths.get(watcher);
19         if (paths == null) 
20             paths = new HashSet<String>();
21             watch2Paths.put(watcher, paths);
22         
23         paths.add(path);
24     
25     
26     public synchronized void removeWatcher(Watcher watcher) 
27         //从watch2Paths和watchTable删除watcher
28         HashSet<String> paths = watch2Paths.remove(watcher);
29         if (paths == null) 
30             return;
31         
32         for (String p : paths) 
33             HashSet<Watcher> list = watchTable.get(p);
34             if (list != null) 
35                 list.remove(watcher);
36                 if (list.size() == 0) 
37                     watchTable.remove(p);
38                 
39             
40         
41     
42     //触发watcher
43     public Set<Watcher> triggerWatch(String path, EventType type, Set<Watcher> supress) 
44         WatchedEvent e = new WatchedEvent(type,
45                 KeeperState.SyncConnected, path);
46         HashSet<Watcher> watchers;
47         synchronized (this) 
48             //zookeeper的通知是一次性的，也就是说如果一个路径触发通知后，相应的watcher会从这两个hashmap中删除。
49             watchers = watchTable.remove(path);
50             for (Watcher w : watchers) 
51                 HashSet<String> paths = watch2Paths.get(w);
52                 if (paths != null) 
53                     paths.remove(path);
54                 
55             
56         
57         for (Watcher w : watchers) 
58             if (supress != null && supress.contains(w)) 
59                 continue;
60             
61             w.process(e);
62         
63         return watchers;
64     
65 

 1 //session与零时节点对应关系
 2 private final Map<Long, HashSet<String>> ephemerals =
 3         new ConcurrentHashMap<Long, HashSet<String>>();
 4 //关闭session
 5 void killSession(long session, long zxid) 
 6         //session结束后，删除零时节点
 7         HashSet<String> list = ephemerals.remove(session);
 8         if (list != null) 
 9             for (String path : list) 
10                 try 
11                     deleteNode(path, zxid);
12                  catch (NoNodeException e) 
13                     LOG.warn("Ignoring NoNodeException for path " + path
14                             + " while removing ephemeral for dead session 0x"
15                             + Long.toHexString(session));
16                 
17             
18         
19     

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

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