revert

pisi/comariface.py

@@ -25,46 +25,19 @@ class Error(pisi.Error):
     pass
 
 try:
-    import dbus
+    import comar
 except ImportError:
-    raise Error(_("dbus-python package is not fully installed"))
+    raise Error(_("comar package is not fully installed"))
 
-def is_char_valid(char):
+def get_comar():
-    """Test if char is valid object path character."""
+    """Connect to the comar daemon and return the handle"""
-    char = ord(char)
-    return (char in xrange(65, 91) or
-           char in xrange(97, 123) or
-           char in xrange(48, 58) or
-           char == '_')
     
-def make_object_path(package):
-    """Generates DBus object name from package name."""
-    object = package
-    for char in package:
-        if not is_char_valid(char):
-            object = object.replace(char, '_')
-    return object
-
-def get_iface(package="", model=""):
-    """Connect to the DBus daemon and return the system interface."""
-    
-    """
     sockname = "/var/run/comar.socket"
     # YALI starts comar chrooted in the install target, but uses PiSi outside of
     # the chroot environment, so PiSi needs to use a different socket path to be
     # able to connect true comar (usually /mnt/target/var/run/comar.socket).
     if ctx.comar_sockname:
         sockname = ctx.comar_sockname
-    """
-    
-    if package:
-        obj_path = "/package/%s" % package
-    else:
-        obj_path = "/"
-    if model:
-        obj_interface = "tr.org.pardus.comar.%s" % model
-    else:
-        obj_interface = "tr.org.pardus.comar"
     
     # This function is sometimes called when comar has recently started
     # or restarting after an update. So we give comar a chance to become
@@ -72,40 +45,71 @@ def get_iface(package="", model=""):
     timeout = 7
     while timeout > 0:
         try:
-            bus = dbus.SystemBus()
+            com = comar.Link(sockname)
-            obj = bus.get_object("tr.org.pardus.comar", obj_path)
+            return com
-            iface = dbus.Interface(obj, dbus_interface=obj_interface)
+        except comar.CannotConnect:
-            return iface
-        except dbus.DBusException:
             pass
         time.sleep(0.2)
         timeout -= 0.2
-    raise Error(_("cannot connect to dbus"))
+    raise Error(_("cannot connect to comar"))
+
+def wait_for_result(com, package_name=None):
+    multiple = False
+    while True:
+        try:
+            reply = com.read_cmd()
+        except select.error:
+            if ctx.keyboard_interrupt_pending():
+                return
+            raise
+        except comar.LinkClosed:
+            # Comar postInstall does a "service comar restart" which cuts
+            # our precious communication link, so we waitsss
+            if package_name == "comar":
+                try:
+                    get_comar()
+                except Error:
+                    raise Error, _("Could not restart comar")
+                return
+            else:
+                if ctx.keyboard_interrupt_pending():
+                    return
+                raise Error, _("connection with comar unexpectedly closed")
+        
+        cmd = reply[0]
+        if cmd == com.RESULT and not multiple:
+            return
+        elif cmd == com.NONE and not multiple:
+            # no post/pre function, that is ok
+            return
+        elif cmd == com.RESULT_START:
+            multiple = True
+        elif cmd == com.RESULT_END:
+            return
+        elif cmd == com.FAIL:
+            raise Error, _("Configuration error: %s") % reply[2]
+        elif cmd == com.ERROR:
+            raise Error, _("Script error: %s") % reply[2]
+        elif cmd == com.DENIED:
+            raise Error, _("comar denied our access")
 
 def post_install(package_name, provided_scripts, scriptpath, metapath, filepath, fromVersion, fromRelease, toVersion, toRelease):
     """Do package's post install operations"""
     
     ctx.ui.info(_("Configuring %s package") % package_name)
     self_post = False
-    sys_iface = get_iface()
+    com = get_comar()
-    object_name = make_object_path(package_name)
     
     for script in provided_scripts:
         ctx.ui.debug(_("Registering %s comar script") % script.om)
         if script.om == "System.Package":
             self_post = True
-        try:
+        com.register(script.om, package_name, os.path.join(scriptpath, script.script))
-            sys_iface.register(object_name, script.om, os.path.join(scriptpath, script.script))
+        wait_for_result(com)
-        except dbus.DBusException, exception:
-            raise Error, _("Script error: %s") % exception
     
     ctx.ui.debug(_("Calling post install handlers"))
-    for handler in sys_iface.listModelApplications("System.PackageHandler"):
+    com.call("System.PackageHandler.setupPackage", [ "metapath", metapath, "filepath", filepath ])
-        iface = get_iface(handler, "System.PackageHandler")
+    wait_for_result(com)
-        try:
-            iface.setupPackage(metapath, filepath)
-        except dbus.DBusException, exception:
-            raise Error, _("Script error: %s") % exception
     
     if self_post:
         args = {
@@ -115,37 +119,23 @@ def post_install(package_name, provided_scripts, scriptpath, metapath, filepath,
             "toRelease": toRelease,
         }
         ctx.ui.debug(_("Running package's post install script"))
-        try:
+        com.call_package("System.Package.postInstall", package_name, args)
-            iface = get_iface(object_name, "System.Package")
+        wait_for_result(com, package_name)
-            iface.postInstall(fromVersion, toVersion, fromRelease, toRelease)
-        except dbus.DBusException, exception:
-            raise Error, _("Script error: %s") % exception
 
 def pre_remove(package_name, metapath, filepath):
     """Do package's pre removal operations"""
     
     ctx.ui.info(_("Configuring %s package for removal") % package_name)
-    sys_iface = get_iface()
+    com = get_comar()
-    object_name = make_object_path(package_name)
     
-    if "System.Package" in sys_iface.listApplicationModels(object_name):
     ctx.ui.debug(_("Running package's pre remove script"))
-        iface = get_iface(handler_application, "System.PackageHandler")
+    com.call_package("System.Package.preRemove", package_name)
-        try:
+    wait_for_result(com)
-            iface.preRemove()
-        except dbus.DBusException, exception:
-            raise Error, _("Script error: %s") % exception
     
     ctx.ui.debug(_("Calling pre remove handlers"))
-    for handler in sys_iface.listModelApplications("System.PackageHandler"):
+    com.call("System.PackageHandler.cleanupPackage", [ "metapath", metapath, "filepath", filepath ])
-        iface = get_iface(handler, "System.PackageHandler")
+    wait_for_result(com)
-        try:
-            iface.cleanupPackage(metapath, filepath)
-        except dbus.DBusException, exception:
-            raise Error, _("Script error: %s") % exception
     
     ctx.ui.debug(_("Unregistering comar scripts"))
-    try:
+    com.remove(package_name)
-        sys_iface.remove(object_name)
+    wait_for_result(com)
-    except dbus.DBusException, exception:
-        raise Error, _("Script error: %s") % exception