[Xen-changelog] setup.py:

[BitKeeper Bot <riel@xxxxxxxxxxx>]

ChangeSet 1.1662.1.18, 2005/06/07 14:38:16+01:00, cl349@xxxxxxxxxxxxxxxxxxxx

        setup.py:
          Add xen.xend.xenstore.
        xsresource.py, xsobj.py, xsnode.py, __init__.py:
          new file
        Signed-off-by: Mike Wray <mike.wray@xxxxxx>
        Signed-off-by: Christian Limpach <Christian.Limpach@xxxxxxxxxxxx>



 setup.py                        |    1 
 xen/xend/xenstore/__init__.py   |    2 
 xen/xend/xenstore/xsnode.py     |  382 +++++++++++++++++++++++++++++
 xen/xend/xenstore/xsobj.py      |  519 ++++++++++++++++++++++++++++++++++++++++
 xen/xend/xenstore/xsresource.py |  136 ++++++++++
 5 files changed, 1040 insertions(+)


diff -Nru a/tools/python/setup.py b/tools/python/setup.py
--- a/tools/python/setup.py     2005-06-09 13:09:22 -04:00
+++ b/tools/python/setup.py     2005-06-09 13:09:22 -04:00
@@ -48,6 +48,7 @@
                          'xen.util',
                          'xen.xend',
                          'xen.xend.server',
+                         'xen.xend.xenstore',
                          'xen.xm',
                          'xen.web',
                          ],
diff -Nru a/tools/python/xen/xend/xenstore/__init__.py 
b/tools/python/xen/xend/xenstore/__init__.py
--- /dev/null   Wed Dec 31 16:00:00 196900
+++ b/tools/python/xen/xend/xenstore/__init__.py        2005-06-09 13:09:22 
-04:00
@@ -0,0 +1,2 @@
+from xsnode import *
+from xsobj import *
diff -Nru a/tools/python/xen/xend/xenstore/xsnode.py 
b/tools/python/xen/xend/xenstore/xsnode.py
--- /dev/null   Wed Dec 31 16:00:00 196900
+++ b/tools/python/xen/xend/xenstore/xsnode.py  2005-06-09 13:09:22 -04:00
@@ -0,0 +1,382 @@
+import errno
+import os
+import os.path
+import select
+import sys
+import time
+
+from xen.lowlevel import xs
+from xen.xend import sxp
+from xen.xend.PrettyPrint import prettyprint
+
+SELECT_TIMEOUT = 2.0
+
+def getEventPath(event):
+    return os.path.join("/_event", event)
+
+def getEventIdPath(event):
+    return os.path.join(eventPath(event), "@eid")
+
+class Subscription:
+
+    def __init__(self, event, fn, id):
+        self.event = event
+        self.watcher = None
+        self.fn = fn
+        self.id = id
+
+    def watch(self, watcher):
+        self.watcher = watcher
+        watcher.addSubs(self)
+
+    def unwatch(self):
+        watcher = self.watcher
+        if watcher:
+            self.watcher = None
+            watcher.delSubs(self)
+
+    def notify(self, event):
+        try:
+            self.fn(event, id)
+        except SystemExitException:
+            raise
+        except:
+            pass
+
+class Watcher:
+
+    def __init__(self, store, event):
+        self.path = getEventPath(event)
+        self.eidPath = getEventIdPath(event)
+        store.mkdirs(self.path)
+        if not store.exists(self.eidPath):
+            store.writeInt(self.eidPath, 0)
+        self.xs = None
+        self.subs = []
+
+    def __getattr__(self, k, v):
+        if k == "fileno":
+            if self.xs:
+                return self.xs.fileno
+            else:
+                return -1
+        else:
+            return self.__dict__.get(k, v)
+
+    def addSubs(self, subs):
+        self.subs.append(subs)
+        self.watch()
+
+    def delSubs(self, subs):
+        self.subs.remove(subs)
+        if len(self.subs) == 0:
+            self.unwatch()
+
+    def getEvent(self):
+        return self.event
+
+    def watch(self):
+        if self.xs: return
+        self.xs = xs.open()
+        self.xs.watch(path)
+
+    def unwatch(self):
+        if self.xs:
+            self.xs.unwatch(self.path)
+            self.xs.close()
+            self.xs = None
+            
+    def watching(self):
+        return self.xs is not None
+
+    def getNotification(self):
+        p = self.xs.read_watch()
+        self.xs.acknowledge_watch()
+        eid = self.xs.readInt(self.eidPath)
+        return p
+
+    def notify(self, subs):
+        p = self.getNotification()
+        for s in subs:
+            s.notify(p)
+            
+class XenStore:
+
+    def __init__(self):
+        self.xs = None
+        #self.xs = xs.open()
+        self.subscription = {}
+        self.subscription_id = 0
+        self.events = {}
+        self.write("/", "")
+
+    def getxs(self):
+        if self.xs is None:
+            ex = None
+            for i in range(0,20):
+                try:
+                    self.xs = xs.open()
+                    ex = None
+                    break
+                except Exception, ex:
+                    print >>stderr, "Exception connecting to xsdaemon:", ex
+                    print >>stderr, "Trying again..."
+                    time.sleep(1)
+            else:
+                raise ex
+            
+        #todo would like to reconnect if xs conn closes (e.g. daemon restart).
+        return self.xs
+
+    def dump(self, path="/", out=sys.stdout):
+        print 'dump>', path
+        val = ['node']
+        val.append(['path',  path])
+##         perms = ['perms']
+##         for p in self.getPerms(path):
+##             l = ['perm']
+##             l.append('dom', p.get['dom'])
+##             for k in ['read', 'write', 'create', 'owner']:
+##                 v = p.get(k)
+##                 l.append([k, v])
+##             perms.append(l)
+##         val.append(perms)
+        data = self.read(path)
+        if data:
+            val.append(['data',  data])
+        children = ['children']
+        for x in self.lsPaths(path):
+            print 'dump>', 'child=', x
+            children.append(self.dump(x))
+        if len(children) > 1:
+            val.append(children)
+        prettyprint(val, out=out)
+        return val
+
+    def getPerms(self, path):
+        return self.getxs().get_permissions(path)
+
+    def ls(self, path="/"):
+        return self.getxs().ls(path)
+
+    def lsPaths(self, path="/"):
+        return [ os.path.join(path, x) for x in self.ls(path) ]
+
+    def lsr(self, path="/", list=None):
+        if list is None:
+            list = []
+        list.append(path)
+        for x in self.lsPaths(path):
+            list.append(x)
+            self.lsr(x, list=list)
+        return list
+
+    def rm(self, path):
+        try:
+            #for x in self.lsPaths():
+            #    self.getxs().rm(x)
+            self.getxs().rm(path)
+        except:
+            pass
+
+    def exists(self, path):
+        try:
+            self.getxs().ls(path)
+            return True
+        except RuntimeError, ex:
+            if ex.args[0] == errno.ENOENT:
+                return False
+            else:
+                raise
+
+    def mkdirs(self, path):
+        if self.exists(path):
+            return
+        elts = path.split("/")
+        p = "/"
+        for x in elts:
+            if x == "": continue
+            p = os.path.join(p, x)
+            if not self.exists(p):
+                self.getxs().write(p, "", create=True)
+
+    def read(self, path):
+        try:
+            return self.getxs().read(path)
+        except RuntimeError, ex:
+            if ex.args[0] == errno.EISDIR:
+                return None
+            else:
+                raise
+
+    def create(self, path, excl=False):
+        self.write(path, "", create=True, excl=excl)
+
+    def write(self, path, data, create=True, excl=False):
+        self.mkdirs(path)
+        self.getxs().write(path, data, create=create, excl=excl)
+
+    def begin(self, path):
+        self.getxs().begin_transaction(path)
+
+    def commit(self, abandon=False):
+        self.getxs().end_transaction(abort=abandon)
+
+    def subscribe(self, event, fn):
+        watcher = self.watchEvent(event)
+        self.subscription_id += 1
+        subs = Subscription(event, fn, self.subscription_id)
+        self.subscription[subs.id] = subs

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog