From 17976dc98c4324213ec112a8724a21605e94bb51 Mon Sep 17 00:00:00 2001
From: zmsdev <zmsdeveloper@gmail.com>
Date: Tue, 5 May 2026 09:58:53 +0200
Subject: [PATCH 1/9] Test Performance Multisite

---
 Products/zms/ZMSMetaobjManager.py | 64 ++++++++++++++++---------------
 Products/zms/_cachemanager.py     | 17 ++++++++
 Products/zms/_confmanager.py      | 33 ++++++++++------
 3 files changed, 72 insertions(+), 42 deletions(-)

diff --git a/Products/zms/ZMSMetaobjManager.py b/Products/zms/ZMSMetaobjManager.py
index 314bacba9..1a15b99ba 100644
--- a/Products/zms/ZMSMetaobjManager.py
+++ b/Products/zms/ZMSMetaobjManager.py
@@ -508,7 +508,34 @@ def renderTemplate(self, obj):
       obj.clear_request_context(obj.REQUEST, prefix)
       return v
 
-
+    def __aq_metaobjs__(self, aqs=[]):
+      """
+      Resolve acquired meta-object entries from portal master.
+      """
+      aq_obs = {}
+      if not aqs: return aq_obs
+      unresolved = []
+      for aq in aqs:
+        subobjects = aq.get('subobjects')
+        ob = self.model.get(aq['id'])
+        if ob and not ob.get('acquired') == 1:
+          aq_ob = {'acquired': 1, 'subobjects': subobjects, **ob}
+          aq_obs[id] = aq_ob
+          if aq_ob.get('type') == 'ZMSPackage' and subobjects == 1:
+            package = aq_ob['id']
+            for sub_id, sub_ob in self.model.items():
+              if sub_ob.get('package') == package:
+                aq_sub_ob = {'acquired': 1, **sub_ob}
+                aq_obs[sub_id] = aq_sub_ob
+        else:
+          unresolved.append(aq)
+      if unresolved:
+        portalMaster = self.getPortalMaster()
+        if portalMaster:
+          # merge, portal master first to allow local override
+          aq_obs = {**portalMaster.metaobj_manager.__aq_metaobjs__(unresolved), **aq_obs}
+      return aq_obs
+    
     def __get_metaobjs__(self):
       """
       Return all meta-objects, including acquired entries from portal master.
@@ -523,36 +550,11 @@ def __get_metaobjs__(self):
       try: return self.fetchReqBuff(reqBuffId)
       except: pass
       # Get value.
-      obs = {}
-      m = self.model
-      aq_obs = None
-      for id in m:
-        ob = m[id]
-        # handle acquisition
-        if ob.get('acquired', 0) == 1:
-          acquired = 1
-          subobjects = ob.get('subobjects', 1)
-          if aq_obs is None:
-            portalMaster = self.getPortalMaster()
-            if portalMaster is not None:
-              aq_obs = portalMaster.metaobj_manager.__get_metaobjs__()
-          if aq_obs is not None:
-            if id in aq_obs:
-              ob = aq_obs[id].copy()
-            else:
-              ob = {'id':id,'type':'ZMSUnknown'}
-            ob['acquired'] = acquired
-            ob['subobjects'] = subobjects
-            obs[id] =  ob
-            if ob['type'] == 'ZMSPackage' and ob['subobjects'] == 1:
-              for aq_id in aq_obs:
-                ob = aq_obs[aq_id].copy()
-                if ob.get( 'package') == id:
-                  ob['acquired'] = 1
-                  obs[aq_id] =  ob
-        else:
-          obs[id] = ob
-      return self.storeReqBuff( reqBuffId, obs)
+      own_obs = {id: ob for id, ob in self.model.items() if not ob.get('acquired') == 1}
+      aq_obs = [ob for ob in self.model.values() if ob.get('acquired') == 1]
+      master_obs = self.__aq_metaobjs__(aq_obs)
+      total_obs = {**own_obs, **master_obs}
+      return self.storeReqBuff( reqBuffId, total_obs)
 
 
     def __get_metaobj__(self, id):
diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 2b5f6dd4a..7b1d98804 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -75,6 +75,14 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       @return: The buffered value.
       @rtype: C{object}
       """
+      try:
+        if False:
+          ram_cache = self.restrictedTraverse("ram_cache")
+          cache = ram_cache.ZCacheManager_getCache()
+          value = cache.ZCache_get(self,key)
+          print("RAMCacheManager ", key, "=", value)
+      except Exception as e:
+        print("RAMCacheManager not available:", e)
       request = getattr(self, 'REQUEST', getRequest())
       if key is None: # For debugging purposes, return whole buffer.
         return None   # request.get('__buff__',{})
@@ -96,6 +104,15 @@ def storeReqBuff(self, key, value, REQUEST=None):
       @return: The value that was stored.
       @rtype: C{object}
       """
+      try:
+        if False:
+          ram_cache = self.restrictedTraverse("ram_cache")
+          cache = ram_cache.ZCacheManager_getCache()
+          print("RAMCacheManager.set", key, "=", value)
+          value = cache.ZCache_set(self,key, value)
+      except Exception as e:
+        print("RAMCacheManager not available:", e)
+      request = getattr(self, 'REQUEST', getRequest())
       request = getattr(self, 'REQUEST', getRequest())
       buff = request.get('__buff__', None)
       if buff is None:
diff --git a/Products/zms/_confmanager.py b/Products/zms/_confmanager.py
index a5c6b6f98..9e9edacf0 100644
--- a/Products/zms/_confmanager.py
+++ b/Products/zms/_confmanager.py
@@ -608,12 +608,7 @@ def getConfProperties(self, prefix=None, inherited=False, REQUEST=None):
         r = {x:d[x] for x in d if x.startswith(prefix+'.')}
         return json.dumps(r)
       if inherited:
-        d = list(d)
-        portalMaster = self.getPortalMaster()
-        if portalMaster is not None:
-          l = portalMaster.getConfProperties(prefix,inherited,REQUEST)
-          l = [x for x in l if x not in d and x[:x.find('.')] not in UNINHERITED_PROPERTIES]
-          d.extend(l)
+        d = self.__aq_conf__()
       return d
 
 
@@ -647,6 +642,23 @@ def getReqProperty(self, key, default=None, REQUEST=None):
       return REQUEST.get(key, default)
 
 
+    def __aq_conf__(self, deep=0):
+        if deep == 0:
+            reqBuffId = 'CacheManager.__aq_conf__'
+            try: return self.fetchReqBuff(reqBuffId)
+            except: pass
+        aq_conf = self.get_conf_properties()
+        portalMaster = self.getPortalMaster()
+        if portalMaster:
+            # merge, portal master first to allow local override
+            master_conf = {k:v for k,v in portalMaster.__aq_conf__(deep+1).items() \
+                if k not in UNINHERITED_PROPERTIES and k[:k.find('.')] not in UNINHERITED_PROPERTIES}
+            aq_conf = {**master_conf, **aq_conf}
+        if deep == 0:
+          return self.storeReqBuff( reqBuffId, aq_conf)
+        return aq_conf
+
+
     def get_conf_property(self, *args, **kwargs):
       """
       Return a configuration value, resolving local and inherited defaults.
@@ -718,14 +730,13 @@ def setConfProperty(self, key, value):
       """
       if key.startswith("Portal"):
         self.clearReqBuff()
-      d = self.getConfProperties()
+      d = getattr( self, '__attr_conf_dict__', {})
       if value is None:
         if key in d:
           del d[key]
       else:
         d[key] = value
-      self.__attr_conf_dict__ = d
-      self.__attr_conf_dict__ = self.__attr_conf_dict__.copy()
+      setattr(self, '__attr_conf_dict__', d.copy())
 
     def manage_customizeSystem(self, btn, key, lang, REQUEST, RESPONSE=None):
       """
@@ -977,7 +988,7 @@ def manage_customizeDesign(self, btn, lang, REQUEST, RESPONSE):
       return RESPONSE.redirect('manage_customizeDesignForm?lang=%s&manage_tabs_message=%s'%(lang, message))
 
 
-    def getZMSSysConf(self):
+    def getZMSSysConf(self, createIfNotExists=True):
       """
       Return the ZMSSysConf object, creating and initializing it if it does not already exist.
       
@@ -990,7 +1001,7 @@ def getZMSSysConf(self):
       @rtype: ZMSSysConf
       """
       sys_conf = getattr(self,"sys_conf",None)
-      if sys_conf is None:
+      if sys_conf is None and createIfNotExists:
         sys_conf = _conf.ZMSSysConf()
         self._setObject(sys_conf.id, sys_conf)
         sys_conf = getattr(self, sys_conf.id, None)

From 17e352a56353679268eb61bfb2d514093285daac Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Fri, 19 Jun 2026 16:17:09 +0200
Subject: [PATCH 2/9] fixed /manage_main

---
 Products/zms/ZMSMetaobjManager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Products/zms/ZMSMetaobjManager.py b/Products/zms/ZMSMetaobjManager.py
index 1a15b99ba..9dd959103 100644
--- a/Products/zms/ZMSMetaobjManager.py
+++ b/Products/zms/ZMSMetaobjManager.py
@@ -622,7 +622,7 @@ def getMetaobjIds(self, sort=None, excl_ids=[]):
       if sort == True:
         ids = sorted(ids,key=lambda x:self.display_type(meta_id=x))
       elif sort == False:
-        ids = sorted(ids,key=lambda x:obs[x].get('name',x))
+        ids = sorted(ids,key=lambda x:obs.get(x, {}).get('name', x))
       return ids
 
 

From a909a0c8d90f334ab60a8037418e3821787ee944 Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Tue, 23 Jun 2026 18:41:11 +0200
Subject: [PATCH 3/9] test RAM Cache Manager

---
 Products/zms/_cachemanager.py | 58 ++++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 7b1d98804..e91fecf3e 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -27,6 +27,8 @@
 from Products.zms import standard
 from zope.globalrequest import getRequest
 
+ram_cache_enabled = False
+
 class Buff(object):
   """Lightweight attribute container used for request-local buffering."""
   pass
@@ -56,15 +58,23 @@ def clearReqBuff(self, prefix='', REQUEST=None):
       @param REQUEST: Optional request object.
       @type REQUEST: C{object}
       """
+      reqBuffId = self.getReqBuffId(prefix)
       request = getattr(self, 'REQUEST', getRequest())
       buff = request.get('__buff__', Buff())
-      reqBuffId = self.getReqBuffId(prefix)
       if len(prefix) > 0:
         reqBuffId += '.'
       for key in list(buff.__dict__):
         if key.startswith(reqBuffId):
           delattr(buff, key)
- 
+      try:
+        if ram_cache_enabled:
+          ram_cache = self.restrictedTraverse("ram_cache")
+          cache = ram_cache.ZCacheManager_getCache()
+          #print("RAMCacheManager.clear", reqBuffId)
+          value = cache.ZCache_set(self, reqBuffId, None)
+      except Exception as e:
+        #print("RAMCacheManager not available:", e)
+        pass
 
     def fetchReqBuff(self, key=None, REQUEST=None):
       """
@@ -75,20 +85,23 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       @return: The buffered value.
       @rtype: C{object}
       """
-      try:
-        if False:
-          ram_cache = self.restrictedTraverse("ram_cache")
-          cache = ram_cache.ZCacheManager_getCache()
-          value = cache.ZCache_get(self,key)
-          print("RAMCacheManager ", key, "=", value)
-      except Exception as e:
-        print("RAMCacheManager not available:", e)
+      reqBuffId = self.getReqBuffId(key)
       request = getattr(self, 'REQUEST', getRequest())
       if key is None: # For debugging purposes, return whole buffer.
         return None   # request.get('__buff__',{})
       buff = request['__buff__']
-      reqBuffId = self.getReqBuffId(key)
-      return getattr(buff, reqBuffId)
+      value = getattr(buff, reqBuffId)
+      try:
+        if ram_cache_enabled:
+          if value is None:
+            ram_cache = self.restrictedTraverse("ram_cache")
+            cache = ram_cache.ZCacheManager_getCache()
+            value = cache.ZCache_get(self, reqBuffId)
+            #print("RAMCacheManager.get", reqBuffId, value is not None)
+      except Exception as e:
+        #print("RAMCacheManager not available:", e)
+        pass
+      return value
 
 
     def storeReqBuff(self, key, value, REQUEST=None):
@@ -104,20 +117,21 @@ def storeReqBuff(self, key, value, REQUEST=None):
       @return: The value that was stored.
       @rtype: C{object}
       """
-      try:
-        if False:
-          ram_cache = self.restrictedTraverse("ram_cache")
-          cache = ram_cache.ZCacheManager_getCache()
-          print("RAMCacheManager.set", key, "=", value)
-          value = cache.ZCache_set(self,key, value)
-      except Exception as e:
-        print("RAMCacheManager not available:", e)
-      request = getattr(self, 'REQUEST', getRequest())
+      reqBuffId = self.getReqBuffId(key)
       request = getattr(self, 'REQUEST', getRequest())
       buff = request.get('__buff__', None)
       if buff is None:
         buff = Buff()
-      reqBuffId = self.getReqBuffId(key)
       setattr(buff, reqBuffId, value)
       request.set('__buff__', buff)
+      try:
+        if ram_cache_enabled:
+          ram_cache = self.restrictedTraverse("ram_cache")
+          cache = ram_cache.ZCacheManager_getCache()
+          old_value = cache.ZCache_get(self, reqBuffId)
+          #print("RAMCacheManager.set", reqBuffId, old_value is not None)
+          value = cache.ZCache_set(self, reqBuffId, value)
+      except Exception as e:
+        #print("RAMCacheManager not available:", e)
+        pass
       return value

From 70737605ccc5a98f118b50a30baeb46ff8ac8943 Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Tue, 23 Jun 2026 19:18:05 +0200
Subject: [PATCH 4/9] optimize RAM Cache Manager

---
 Products/zms/_cachemanager.py | 82 ++++++++++++++++++++++-------------
 1 file changed, 52 insertions(+), 30 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index e91fecf3e..086092a25 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -28,6 +28,33 @@
 from zope.globalrequest import getRequest
 
 ram_cache_enabled = False
+ram_cache_key = 'ram_cache'
+
+def get_ram_cache(self, request, buff):
+    cache = None
+    if ram_cache_enabled:
+        cache = getattr(buff, ram_cache_key, None)
+        if cache is None:
+            ram_cache = self.restrictedTraverse(ram_cache_key)
+            cache = ram_cache.ZCacheManager_getCache()
+            setattr(buff, ram_cache_key, cache)
+            set_buff(request, buff)
+    return cache
+
+def get_request(self):
+    return getattr(self, 'REQUEST', getRequest())
+
+buff_key = '__buff__'
+
+def get_buff(request):
+    buff = getattr(request, buff_key, None)
+    if buff is None:
+        buff = Buff()
+        setattr(request, buff_key, buff)
+    return buff
+
+def set_buff(request, buff):
+    setattr(request, buff_key, buff)
 
 class Buff(object):
   """Lightweight attribute container used for request-local buffering."""
@@ -46,7 +73,7 @@ def getReqBuffId(self, key):
       @return: Namespaced buffer key.
       @rtype: C{str}
       """
-      return '%s_%s'%('_'.join(self.getPhysicalPath()[2:]), key)
+      return '%s_%s'%('_'.join(self.getPhysicalPath()), key)
 
 
     def clearReqBuff(self, prefix='', REQUEST=None):
@@ -59,17 +86,18 @@ def clearReqBuff(self, prefix='', REQUEST=None):
       @type REQUEST: C{object}
       """
       reqBuffId = self.getReqBuffId(prefix)
-      request = getattr(self, 'REQUEST', getRequest())
-      buff = request.get('__buff__', Buff())
+      request = get_request(self)
+      buff = get_buff(request)
       if len(prefix) > 0:
         reqBuffId += '.'
       for key in list(buff.__dict__):
         if key.startswith(reqBuffId):
           delattr(buff, key)
+      set_buff(request, buff)
+      # RAM cache is optional, so we ignore errors if it's not available.
       try:
-        if ram_cache_enabled:
-          ram_cache = self.restrictedTraverse("ram_cache")
-          cache = ram_cache.ZCacheManager_getCache()
+        cache = get_ram_cache(self, request, buff)
+        if cache:
           #print("RAMCacheManager.clear", reqBuffId)
           value = cache.ZCache_set(self, reqBuffId, None)
       except Exception as e:
@@ -86,21 +114,19 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       @rtype: C{object}
       """
       reqBuffId = self.getReqBuffId(key)
-      request = getattr(self, 'REQUEST', getRequest())
-      if key is None: # For debugging purposes, return whole buffer.
-        return None   # request.get('__buff__',{})
-      buff = request['__buff__']
+      request = get_request(self)
+      buff = get_buff(request)
       value = getattr(buff, reqBuffId)
-      try:
-        if ram_cache_enabled:
-          if value is None:
-            ram_cache = self.restrictedTraverse("ram_cache")
-            cache = ram_cache.ZCacheManager_getCache()
-            value = cache.ZCache_get(self, reqBuffId)
-            #print("RAMCacheManager.get", reqBuffId, value is not None)
-      except Exception as e:
-        #print("RAMCacheManager not available:", e)
-        pass
+      if value is None:
+        # RAM cache is optional, so we ignore errors if it's not available.
+        try:
+          cache = get_ram_cache(self, request, buff)
+          if cache:
+              value = cache.ZCache_get(self, reqBuffId)
+              #print("RAMCacheManager.get", reqBuffId, value is not None)
+        except Exception as e:
+          #print("RAMCacheManager not available:", e)
+          pass
       return value
 
 
@@ -118,18 +144,14 @@ def storeReqBuff(self, key, value, REQUEST=None):
       @rtype: C{object}
       """
       reqBuffId = self.getReqBuffId(key)
-      request = getattr(self, 'REQUEST', getRequest())
-      buff = request.get('__buff__', None)
-      if buff is None:
-        buff = Buff()
+      request = get_request(self)
+      buff = get_buff(request)
       setattr(buff, reqBuffId, value)
-      request.set('__buff__', buff)
+      set_buff(request, buff)
+      # RAM cache is optional, so we ignore errors if it's not available.
       try:
-        if ram_cache_enabled:
-          ram_cache = self.restrictedTraverse("ram_cache")
-          cache = ram_cache.ZCacheManager_getCache()
-          old_value = cache.ZCache_get(self, reqBuffId)
-          #print("RAMCacheManager.set", reqBuffId, old_value is not None)
+        cache = get_ram_cache(self, request, buff)
+        if cache:
           value = cache.ZCache_set(self, reqBuffId, value)
       except Exception as e:
         #print("RAMCacheManager not available:", e)

From c90f643591dfaaa95663a1c2e4c08ae8c2f0951e Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Tue, 23 Jun 2026 19:29:03 +0200
Subject: [PATCH 5/9] hash reqzest-buff id

---
 Products/zms/_cachemanager.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 086092a25..3251deaf8 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -73,7 +73,8 @@ def getReqBuffId(self, key):
       @return: Namespaced buffer key.
       @rtype: C{str}
       """
-      return '%s_%s'%('_'.join(self.getPhysicalPath()), key)
+      path = self.getPhysicalPath()
+      return f"{hash(path)}_{key}"
 
 
     def clearReqBuff(self, prefix='', REQUEST=None):

From 10f05d4ac53d49c0dbdbd4f9f518b32ea104ff18 Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Wed, 24 Jun 2026 01:38:04 +0200
Subject: [PATCH 6/9] fix RAM Cache

---
 Products/zms/_cachemanager.py | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 3251deaf8..768bd4aba 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -26,6 +26,7 @@
 # Imports.
 from Products.zms import standard
 from zope.globalrequest import getRequest
+import time
 
 ram_cache_enabled = False
 ram_cache_key = 'ram_cache'
@@ -33,12 +34,12 @@
 def get_ram_cache(self, request, buff):
     cache = None
     if ram_cache_enabled:
-        cache = getattr(buff, ram_cache_key, None)
+        cache = None #getattr(buff, ram_cache_key, None)
         if cache is None:
             ram_cache = self.restrictedTraverse(ram_cache_key)
             cache = ram_cache.ZCacheManager_getCache()
-            setattr(buff, ram_cache_key, cache)
-            set_buff(request, buff)
+            #setattr(buff, ram_cache_key, cache)
+            #set_buff(request, buff)
     return cache
 
 def get_request(self):
@@ -102,7 +103,7 @@ def clearReqBuff(self, prefix='', REQUEST=None):
           #print("RAMCacheManager.clear", reqBuffId)
           value = cache.ZCache_set(self, reqBuffId, None)
       except Exception as e:
-        #print("RAMCacheManager not available:", e)
+        print("RAMCacheManager not available:", e)
         pass
 
     def fetchReqBuff(self, key=None, REQUEST=None):
@@ -117,19 +118,25 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       reqBuffId = self.getReqBuffId(key)
       request = get_request(self)
       buff = get_buff(request)
-      value = getattr(buff, reqBuffId)
-      if value is None:
+      if not hasattr(buff, reqBuffId):
         # RAM cache is optional, so we ignore errors if it's not available.
         try:
           cache = get_ram_cache(self, request, buff)
           if cache:
               value = cache.ZCache_get(self, reqBuffId)
-              #print("RAMCacheManager.get", reqBuffId, value is not None)
+              if value:
+                  print("RAMCacheManager.get", reqBuffId, value is not None)
+                  setattr(buff, reqBuffId, value)
+                  set_buff(request, buff)
+                  return value
         except Exception as e:
-          #print("RAMCacheManager not available:", e)
+          print("RAMCacheManager not available:", e)
           pass
-      return value
+      return getattr(buff, reqBuffId)
+
 
+    def ZCacheable_getModTime(self, *args, **kwargs):
+        return time.time()
 
     def storeReqBuff(self, key, value, REQUEST=None):
       """
@@ -153,8 +160,9 @@ def storeReqBuff(self, key, value, REQUEST=None):
       try:
         cache = get_ram_cache(self, request, buff)
         if cache:
-          value = cache.ZCache_set(self, reqBuffId, value)
+          cache.ZCache_set(self, reqBuffId, value)
+          #print("RAMCacheManager.set", reqBuffId, value is not None)
       except Exception as e:
-        #print("RAMCacheManager not available:", e)
+        print("RAMCacheManager not available:", e)
         pass
       return value

From ddd98547e1a7f8d194475b82426b81fc0e0a3b3e Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Wed, 24 Jun 2026 01:51:08 +0200
Subject: [PATCH 7/9] fix RAM Cache

---
 Products/zms/_cachemanager.py | 7 +++++--
 Products/zms/rest_api.py      | 1 -
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 768bd4aba..82d42fd78 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -36,14 +36,17 @@ def get_ram_cache(self, request, buff):
     if ram_cache_enabled:
         cache = None #getattr(buff, ram_cache_key, None)
         if cache is None:
-            ram_cache = self.restrictedTraverse(ram_cache_key)
+            ram_cache = getattr(self, ram_cache_key)
             cache = ram_cache.ZCacheManager_getCache()
             #setattr(buff, ram_cache_key, cache)
             #set_buff(request, buff)
     return cache
 
 def get_request(self):
-    return getattr(self, 'REQUEST', getRequest())
+    request = getattr(self, 'REQUEST', None)
+    if request: 
+        return request
+    return getRequest()
 
 buff_key = '__buff__'
 
diff --git a/Products/zms/rest_api.py b/Products/zms/rest_api.py
index 141ce7c37..a9647a7ca 100644
--- a/Products/zms/rest_api.py
+++ b/Products/zms/rest_api.py
@@ -154,7 +154,6 @@ def __init__(self, context=None, TraversalRequest=None):
             self.ids = [x for x in self.path_to_handle if x != '++rest_api'] # remove ++rest_api as first element
             while self.ids:
                 id = self.ids[0]
-                print(id,context)
                 if id.startswith('uid:'):
                   context = context.getLinkObj('{$%s}'%id)
                 elif id not in context.getPhysicalPath():

From 7ee49ec827f834ab7aebb4c6914b61343578906a Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Wed, 24 Jun 2026 09:00:29 +0200
Subject: [PATCH 8/9] fixed RAM Cache

---
 Products/zms/_cachemanager.py | 37 ++++++++++++++++++++++++-----------
 Products/zms/_confmanager.py  | 22 ++++++++++-----------
 2 files changed, 36 insertions(+), 23 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index 82d42fd78..e50624890 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -26,11 +26,26 @@
 # Imports.
 from Products.zms import standard
 from zope.globalrequest import getRequest
-import time
 
-ram_cache_enabled = False
+ram_cache_enabled = True
 ram_cache_key = 'ram_cache'
 
+class DummyCacheable:
+    def __init__(self, ob):
+        self._ob = ob
+
+    def ZCacheable_getModTime(self, *args, **kwargs):
+        return 0
+
+    def ZCacheable_getIdentifier(self):
+        return "/".join(self._ob.getPhysicalPath())
+
+    def ZCacheable_isCachingEnabled(self):
+        return True
+
+    def getPhysicalPath(self):
+        return self._ob.getPhysicalPath()
+
 def get_ram_cache(self, request, buff):
     cache = None
     if ram_cache_enabled:
@@ -103,8 +118,9 @@ def clearReqBuff(self, prefix='', REQUEST=None):
       try:
         cache = get_ram_cache(self, request, buff)
         if cache:
-          #print("RAMCacheManager.clear", reqBuffId)
-          value = cache.ZCache_set(self, reqBuffId, None)
+          #print("RAMCacheManager.clear", key)
+          cacheable = DummyCacheable(self)
+          value = cache.ZCache_set(cacheable, key, None)
       except Exception as e:
         print("RAMCacheManager not available:", e)
         pass
@@ -126,9 +142,10 @@ def fetchReqBuff(self, key=None, REQUEST=None):
         try:
           cache = get_ram_cache(self, request, buff)
           if cache:
-              value = cache.ZCache_get(self, reqBuffId)
+              cacheable = DummyCacheable(self)
+              value = cache.ZCache_get(cacheable, key)
               if value:
-                  print("RAMCacheManager.get", reqBuffId, value is not None)
+                  #print("RAMCacheManager.get", key, value is not None)
                   setattr(buff, reqBuffId, value)
                   set_buff(request, buff)
                   return value
@@ -138,9 +155,6 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       return getattr(buff, reqBuffId)
 
 
-    def ZCacheable_getModTime(self, *args, **kwargs):
-        return time.time()
-
     def storeReqBuff(self, key, value, REQUEST=None):
       """
       Store and return a value in the current request buffer.
@@ -163,8 +177,9 @@ def storeReqBuff(self, key, value, REQUEST=None):
       try:
         cache = get_ram_cache(self, request, buff)
         if cache:
-          cache.ZCache_set(self, reqBuffId, value)
-          #print("RAMCacheManager.set", reqBuffId, value is not None)
+          cacheable = DummyCacheable(self)
+          cache.ZCache_set(cacheable, value, key)
+          #print("RAMCacheManager.set", key, value is not None)
       except Exception as e:
         print("RAMCacheManager not available:", e)
         pass
diff --git a/Products/zms/_confmanager.py b/Products/zms/_confmanager.py
index 9e9edacf0..4407cf44b 100644
--- a/Products/zms/_confmanager.py
+++ b/Products/zms/_confmanager.py
@@ -652,7 +652,9 @@ def __aq_conf__(self, deep=0):
         if portalMaster:
             # merge, portal master first to allow local override
             master_conf = {k:v for k,v in portalMaster.__aq_conf__(deep+1).items() \
-                if k not in UNINHERITED_PROPERTIES and k[:k.find('.')] not in UNINHERITED_PROPERTIES}
+                if not k in UNINHERITED_PROPERTIES \
+                  and not k[:k.find('.')] in UNINHERITED_PROPERTIES \
+                  and not k in ['UniBE.Alias', 'UniBE.Server']}
             aq_conf = {**master_conf, **aq_conf}
         if deep == 0:
           return self.storeReqBuff( reqBuffId, aq_conf)
@@ -687,19 +689,15 @@ def get_conf_property(self, *args, **kwargs):
         if key in OFS.misc_.misc_.zms['confdict']:
           default = OFS.misc_.misc_.zms['confdict'].get(key)
       value = default
-      confdict = self.getConfProperties()
+      confdict = self.getConfProperties(inherited=True)
       if key in confdict:
         value = confdict.get(key)
-      elif key is not None and not key[:key.find('.')] in UNINHERITED_PROPERTIES and not key in ['UniBE.Alias', 'UniBE.Server']:
-        portalMaster = self.getPortalMaster()
-        if portalMaster is not None:
-          value = portalMaster.getConfProperty( key)
-        if value is None:
-          if 'default' in kwargs:
-            value = default
-          else:
-            for default in [x for x in self.default_conf_properties if x['key'] == key]:
-              value = default.get('default', None)
+      else:
+        if 'default' in kwargs:
+          value = default
+        else:
+          for default in [x for x in self.default_conf_properties if x['key'] == key]:
+            value = default.get('default', None)
       return value 
 
 

From 21e68dc1644e45bf80093e0a8f5855b665c00b0b Mon Sep 17 00:00:00 2001
From: zmsdev <33760154+zmsdev@users.noreply.github.com>
Date: Wed, 24 Jun 2026 10:56:23 +0200
Subject: [PATCH 9/9] synchronize with memcache-pull-request

---
 Products/zms/_cachemanager.py | 35 ++++++++++++-----------------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/Products/zms/_cachemanager.py b/Products/zms/_cachemanager.py
index e50624890..b70c71f37 100644
--- a/Products/zms/_cachemanager.py
+++ b/Products/zms/_cachemanager.py
@@ -46,15 +46,11 @@ def ZCacheable_isCachingEnabled(self):
     def getPhysicalPath(self):
         return self._ob.getPhysicalPath()
 
-def get_ram_cache(self, request, buff):
+def get_cache(self):
     cache = None
     if ram_cache_enabled:
-        cache = None #getattr(buff, ram_cache_key, None)
-        if cache is None:
-            ram_cache = getattr(self, ram_cache_key)
-            cache = ram_cache.ZCacheManager_getCache()
-            #setattr(buff, ram_cache_key, cache)
-            #set_buff(request, buff)
+        ram_cache = getattr(self, ram_cache_key)
+        cache = ram_cache.ZCacheManager_getCache()
     return cache
 
 def get_request(self):
@@ -114,16 +110,7 @@ def clearReqBuff(self, prefix='', REQUEST=None):
         if key.startswith(reqBuffId):
           delattr(buff, key)
       set_buff(request, buff)
-      # RAM cache is optional, so we ignore errors if it's not available.
-      try:
-        cache = get_ram_cache(self, request, buff)
-        if cache:
-          #print("RAMCacheManager.clear", key)
-          cacheable = DummyCacheable(self)
-          value = cache.ZCache_set(cacheable, key, None)
-      except Exception as e:
-        print("RAMCacheManager not available:", e)
-        pass
+
 
     def fetchReqBuff(self, key=None, REQUEST=None):
       """
@@ -140,17 +127,19 @@ def fetchReqBuff(self, key=None, REQUEST=None):
       if not hasattr(buff, reqBuffId):
         # RAM cache is optional, so we ignore errors if it's not available.
         try:
-          cache = get_ram_cache(self, request, buff)
+          cache = get_cache(self)
           if cache:
               cacheable = DummyCacheable(self)
-              value = cache.ZCache_get(cacheable, key)
+              # Note: keywords/view_name can be used for namespacing if needed.
+              value = cache.ZCache_get(cacheable, view_name='shared', keywords={'key': key})
               if value:
                   #print("RAMCacheManager.get", key, value is not None)
+                  # Store the value in the request buffer for future access.
                   setattr(buff, reqBuffId, value)
                   set_buff(request, buff)
                   return value
         except Exception as e:
-          print("RAMCacheManager not available:", e)
+          print("RAMCacheManager not available:", key, e)
           pass
       return getattr(buff, reqBuffId)
 
@@ -175,12 +164,12 @@ def storeReqBuff(self, key, value, REQUEST=None):
       set_buff(request, buff)
       # RAM cache is optional, so we ignore errors if it's not available.
       try:
-        cache = get_ram_cache(self, request, buff)
+        cache = get_cache(self)
         if cache:
           cacheable = DummyCacheable(self)
-          cache.ZCache_set(cacheable, value, key)
+          cache.ZCache_set(cacheable, value, view_name='shared', keywords={'key': key})
           #print("RAMCacheManager.set", key, value is not None)
       except Exception as e:
-        print("RAMCacheManager not available:", e)
+        print("RAMCacheManager not available:", key, e)
         pass
       return value