git subrepo pull uno

subrepo:
  subdir:   "uno"
  merged:   "8c0644a"
upstream:
  origin:   "https://github.com/prrvchr/uno.git"
  branch:   "main"
  commit:   "8c0644a"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

Author: prrvchr

uno/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/prrvchr/uno.git
 	branch = main
-	commit = a14c230930b565156941b03390abc2b513a8a1e9
-	parent = 34c9531b1e952a8d28eb9b853bbd84b88d74b3af
+	commit = 8c0644af51492f4c8444d3ceeac471c3a8716d7c
+	parent = ad3b72217e16131c12e8c96da91ee264855124bc
 	method = merge
 	cmdver = 0.4.3

uno/lib/uno/embedded/documenthandler.py

@@ -67,7 +67,6 @@ def __init__(self, ctx, lock, logger, url, index):
         self._suffix = '.lck'
         self._lock = lock
         self._logger = logger
-        self._listening = False
         self._created = False
         self._path, self._folder = self._getDataBaseInfo(url)
         self._url = url
@@ -80,11 +79,13 @@ def URL(self):
     # XCloseListener
     def queryClosing(self, event, owner):
         url = self._url
+        print("DocumentHandler.queryClosing() Url: %s" % url)
         self._logger.logprb(INFO, 'DocumentHandler', 'queryClosing()', 201, url)
         with self._lock:
             document = event.Source
-            if self._closeDataBase(document):
-                self.removeFolder()
+            target = document.getDocumentSubStorage(self._directory, READWRITE)
+            if self._closeDataBase(document, target, 'queryClosing()', 241):
+                self._removeFolder()
             self._url = None
         self._logger.logprb(INFO, 'DocumentHandler', 'queryClosing()', 202, url)
 
@@ -95,15 +96,16 @@ def notifyClosing(self, event):
     def notifyStorageChange(self, document, storage):
         # The document has been save as with a new name
         url = document.getLocation()
+        print("DocumentHandler.notifyStorageChange() Url: %s" % url)
         self._logger.logprb(INFO, 'DocumentHandler', 'notifyStorageChange()', 211, url)
         with self._lock:
             newpath, newfolder = self._getDataBaseInfo(url)
-            if self._switchDataBase(document, storage, newfolder):
-                self.removeFolder()
+            target = storage.openStorageElement(self._directory, READWRITE)
+            if self._closeDataBase(document, target, 'notifyStorageChange()', 251):
+                self._removeFolder()
             self._path = newpath
             self._folder = newfolder
             self._url = url
-            #document.removeCloseListener(self)
         self._logger.logprb(INFO, 'DocumentHandler', 'notifyStorageChange()', 212, url)
 
     # XEventListener
@@ -117,25 +119,10 @@ def disposing(self, event):
         self._logger.logprb(INFO, 'DocumentHandler', 'disposing()', 222, url)
 
     # DocumentHandler setter methods
-    def setListener(self, document):
-        # FIXME: With OpenOffice there is no Document in the info
-        # FIXME: parameter provided during the connection
-        if document is None:
-            document = self._getDocument()
-        if document is not None:
-            # FIXME: We want to add the StorageChangeListener only once
-            if not self._listening:
-                document.addStorageChangeListener(self)
-                self._listening = True
-            # FIXME: If storage has been changed the closeListener has been removed
-            document.addCloseListener(self)
-
     def removeFolder(self):
         # XXX: The database folder will be deleted only if it was created
         if self._created:
-            sf = getSimpleFile(self._ctx)
-            if sf.isFolder(self._path):
-                sf.kill(self._path)
+            self._removeFolder()
 
     # DocumentHandler getter methods
     def getConnectionUrl(self, storage):
@@ -151,6 +138,17 @@ def getConnectionUrl(self, storage):
                     self._logger.logprb(INFO, 'DocumentHandler', 'getConnectionUrl()', 231, count)
             return self._getConnectionUrl(exist)
 
+    def getDocument(self):
+        document = None
+        interface = 'com.sun.star.frame.XStorable'
+        components = getDesktop(self._ctx).getComponents().createEnumeration()
+        while components.hasMoreElements():
+            component = components.nextElement()
+            if hasInterface(component, interface) and component.hasLocation() and component.getLocation() == self._url:
+                document = component
+                break
+        return document
+
     # DocumentHandler private getter methods
     def _getDataBaseInfo(self, location):
         transformer = getUrlTransformer(self._ctx)
@@ -177,65 +175,37 @@ def _getDocumentName(self, title):
         name, sep, extension = title.rpartition('.')
         return name if sep else extension
 
-    def _getDocument(self):
-        document = None
-        interface = 'com.sun.star.frame.XStorable'
-        components = getDesktop(self._ctx).getComponents().createEnumeration()
-        while components.hasMoreElements():
-            component = components.nextElement()
-            if hasInterface(component, interface) and component.hasLocation() and component.getLocation() == self._url:
-                document = component
-                break
-        return document
-
     def _getConnectionUrl(self, exist):
         path = self._path[self._index:]
         url = '%s%s/%s%s' % (g_protocol, path, g_catalog, g_options)
         return url + g_exist if exist else url + g_create
 
-    def _getStorageName(self, name, oldname, newname):
-        return name.replace(oldname, newname)
-
-    def _closeDataBase(self, document):
+    def _closeDataBase(self, document, target, method, resource):
         try:
-            target = document.getDocumentSubStorage(self._directory, READWRITE)
             service = 'com.sun.star.embed.FileSystemStorageFactory'
             args = (self._path, SEEKABLEREAD)
             source = createService(self._ctx, service).createInstanceWithArguments(args)
             count = self._copyStorage(source, target)
-            self._logger.logprb(INFO, 'DocumentHandler', '_closeDataBase()', 241, count)
+            self._logger.logprb(INFO, 'DocumentHandler', method, resource, count)
             document.store()
             return True
         except Exception as e:
-            self._logger.logprb(SEVERE, 'DocumentHandler', '_closeDataBase()', 242, self._url, traceback.format_exc())
-            return False
-
-    def _switchDataBase(self, document, storage, newname):
-        try:
-            target = storage.openStorageElement(self._directory, READWRITE)
-            service = 'com.sun.star.embed.FileSystemStorageFactory'
-            args = (self._path, SEEKABLEREAD)
-            source = createService(self._ctx, service).createInstanceWithArguments(args)
-            count = self._copyStorage(source, target)
-            self._logger.logprb(INFO, 'DocumentHandler', '_switchDataBase()', 251, count)
-            document.store()
-            return True
-        except Exception as e:
-            self._logger.logprb(SEVERE, 'DocumentHandler', '_switchDataBase()', 252, self._url, traceback.format_exc())
+            self._logger.logprb(SEVERE, 'DocumentHandler', method, resource + 1, self._url, traceback.format_exc())
             return False
 
     # DocumentHandler private setter methods
     def _copyStorage(self, source, target):
         count = 0
-        for name in source.getElementNames():
-            if source.isStreamElement(name):
-                if target.hasByName(name):
-                    target.removeElement(name)
-                source.copyElementTo(name, target, name)
-                count += 1
-            else:
-                count += self._copyStorage(source.openStorageElement(name, SEEKABLEREAD),
-                                           target.openStorageElement(name, READWRITE))
+        if source.hasElements():
+            for name in source.getElementNames():
+                if source.isStreamElement(name):
+                    if target.hasByName(name):
+                        target.removeElement(name)
+                    source.copyElementTo(name, target, name)
+                    count += 1
+                else:
+                    count += self._copyStorage(source.openStorageElement(name, SEEKABLEREAD),
+                                               target.openStorageElement(name, READWRITE))
         target.commit()
         target.dispose()
         source.dispose()
@@ -260,3 +230,8 @@ def _extractStorage(self, sf, source, url):
     def _getPath(self, path, name):
         return '%s/%s' % (path, name)
 
+    def _removeFolder(self):
+        sf = getSimpleFile(self._ctx)
+        if sf.isFolder(self._path):
+            sf.kill(self._path)
+

uno/lib/uno/embedded/driver.py

@@ -60,6 +60,7 @@
 from .configuration import g_protocol
 from .configuration import g_url
 from .configuration import g_user
+from .configuration import g_lover
 
 import traceback
 
@@ -84,24 +85,25 @@ def __init__(self, ctx, lock, service, name, index):
 
     # XDriver
     def connect(self, url, infos):
-        # XXX: We need to test first if jdbcDriverOOo is installed...
+        # XXX: We need to test first if configuration is OK...
         driver = self._getDriver()
         newinfos, document, storage, location = self._getConnectionInfo(infos)
         if storage is None or location is None:
             self._logException(112, url, ' ')
-            raise self._getException(1001, None, 111, url, '\n')
-        # XXX: Calling handler unpacks the database files
+            raise self._getException(1001, None, 111, 112, url, '\n')
         handler = self._getDocumentHandler(location)
+        # XXX: Getting path from handler unpacks the database files
         path = handler.getConnectionUrl(storage)
         self._logger.logprb(INFO, 'Driver', 'connect()', 113, location)
         try:
             connection = driver.connect(path, newinfos)
         except Exception as e:
             self._logger.logprb(SEVERE, 'Driver', 'connect()', 115, str(e), traceback.format_exc())
+            # XXX: Database files will only be deleted if they have been unpacked
             handler.removeFolder()
             raise e
         # XXX: Connection has been done we can add close and change listener to document
-        handler.setListener(document)
+        self._setDocumentHandler(document, handler)
         version = connection.getMetaData().getDriverVersion()
         self._logger.logprb(INFO, 'Driver', 'connect()', 114, g_dbname, version, g_user)
         return connection
@@ -113,8 +115,10 @@ def acceptsURL(self, url):
 
     def getPropertyInfo(self, url, infos):
         try:
+            # XXX: We need to test first if configuration is OK...
+            driver = self._getDriver()
             self._logger.logprb(INFO, 'Driver', 'getPropertyInfo()', 141, url)
-            drvinfo = self._getDriver().getPropertyInfo(g_protocol, infos)
+            drvinfo = driver.getPropertyInfo(g_protocol, infos)
             for info in drvinfo:
                 self._logger.logprb(INFO, 'Driver', 'getPropertyInfo()', 142, info.Name, info.Value)
             return drvinfo
@@ -143,17 +147,28 @@ def _getDriver(self):
         # FIXME: If jdbcDriverOOo is not installed,
         # FIXME: we need to throw SQLException
         if self._driver is None:
-            version = getExtensionVersion(self._ctx, g_jdbcid)
-            if version is None:
-                self._logException(122, g_jdbcext, ' ', g_extension)
-                raise self._getException(1001, None, 121, g_jdbcext, '\n', g_extension)
-            elif not checkVersion(version, g_jdbcver):
-                self._logException(124, version, g_jdbcext, ' ', g_jdbcver)
-                raise self._getException(1001, None, 123, version, g_jdbcext, '\n', g_jdbcver)
-            else:
-                self._driver = createService(self._ctx, self._service)
+            self._checkConfiguration()
+            self._driver = createService(self._ctx, self._service)
         return self._driver
 
+    def _checkConfiguration(self):
+        self._checkLibreOffice()
+        version = getExtensionVersion(self._ctx, g_jdbcid)
+        if version is None:
+            self._logException(122, g_jdbcext, ' ', g_extension)
+            raise self._getException(1001, None, 121, 123, g_jdbcext, '\n', g_extension)
+        if not checkVersion(version, g_jdbcver):
+            self._logException(125, version, g_jdbcext, ' ', g_jdbcver)
+            raise self._getException(1001, None, 122, 125, version, g_jdbcext, '\n', g_jdbcver)
+
+    def _checkLibreOffice(self):
+        configuration = getConfiguration(self._ctx, '/org.openoffice.Setup/Product')
+        name = configuration.getByName('ooName')
+        version = configuration.getByName('ooSetupVersion')
+        if not checkVersion(version, g_lover):
+            self._logException(124, name, version, ' ', name, g_lover)
+            raise self._getException(1001, None, 122, 124, name, version, '\n', name, g_lover)
+
     def _getConnectionInfo(self, infos):
         document = storage = url = None
         service = getConfiguration(self._ctx, g_identifier).getByName('ConnectionService')
@@ -169,13 +184,14 @@ def _getConnectionInfo(self, infos):
                 document = info.Value
             else:
                 newinfos[info.Name] = info.Value
-                print("Driver._getConnectionInfo() Name: %s - Value: %s" % (info.Name, info.Value))
         return getPropertyValueSet(newinfos), document, storage, url
 
     def _getHandler(self, location):
         document = None
-        for handler in self._handlers:
+        # XXX: If we want to be able to remove dead handler we need to do copy
+        for handler in self._handlers[:]:
             url = handler.URL
+            # XXX: The URL is None for a closed connection and can be cleared.
             if url is None:
                 self._handlers.remove(handler)
             elif url == location:
@@ -187,18 +203,35 @@ def _getDocumentHandler(self, location):
             handler = self._getHandler(location)
             if handler is None:
                 handler = DocumentHandler(self._ctx, self._lock, self._logger, location, self._index)
-                self._handlers.append(handler)
             return handler
 
+    def _setDocumentHandler(self, document, handler):
+        with self._lock:
+            # FIXME: We only add handler if connection is successful
+            if handler not in self._handlers:
+                if self._setListener(document, handler):
+                    self._handlers.append(handler)
+
+    def _setListener(self, document, handler):
+        # FIXME: With OpenOffice there is no Document in the info
+        # FIXME: parameter provided during the connection
+        if document is None:
+            document = handler.getDocument()
+        if document is not None:
+            document.addStorageChangeListener(handler)
+            document.addCloseListener(handler)
+            return True
+        return False
+
     def _logException(self, resource, *args):
         self._logger.logprb(SEVERE, 'Driver', 'connect()', resource, *args)
 
-    def _getException(self, code, exception, resource, *args):
+    def _getException(self, code, exception, state, resource, *args):
         error = SQLException()
         error.ErrorCode = code
         error.NextException = exception
-        error.SQLState = self._logger.resolveString(resource)
-        error.Message = self._logger.resolveString(resource +1, *args)
+        error.SQLState = self._logger.resolveString(state)
+        error.Message = self._logger.resolveString(resource, *args)
         error.Context = self
         return error
 

uno/resource/embedded/Driver_en_US.properties

@@ -10,9 +10,10 @@
 
 120=Driver._getDriver()
 121=Installation error
-122=The extension {} was not found.{}You must install this extension to use {}.
-123=Configuration error
-124=Version {} of extension {} is obsolete.{}You need to update this extension to version: {}.
+122=Configuration error
+123=The extension {} was not found.{}You must install this extension to use {}.
+124={} version {} is obsolete.{}You need to update {} to version: {} minimum.
+125=Version {} of extension {} is obsolete.{}You need to update this extension to version: {}.
 
 130=Driver.acceptsURL()
 131=Driver can open a connection with the URL: {} - {}

uno/resource/embedded/Driver_fr_FR.properties

@@ -10,9 +10,10 @@
 
 120=Driver._getDriver()
 121=Erreur d'installation
-122=L'extension {} est introuvable.{}Vous devez installer cette extension pour utiliser {}.
-123=Erreur de configuration
-124=La version {} de l'extension {} est obsolète.{}Vous devez mettre à jour cette extension vers la version: {}.
+122=Erreur de configuration
+123=L'extension {} est introuvable.{}Vous devez installer cette extension pour utiliser {}.
+124={} version {} est obsolète.{}Vous devez mettre à jour {} vers la version: {} minimum.
+125=La version {} de l'extension {} est obsolète.{}Vous devez mettre à jour cette extension vers la version: {}.
 
 130=Driver.acceptsURL()
 131=Le pilote peut ouvrir une connexion avec l'URL: {} - {}