[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
r5056 - in trunk/gnue-appserver/src: . classrep language
|
From: |
johannes |
|
Subject: |
r5056 - in trunk/gnue-appserver/src: . classrep language |
|
Date: |
Fri, 30 Jan 2004 07:27:48 -0600 (CST) |
Author: johannes
Date: 2004-01-30 07:27:47 -0600 (Fri, 30 Jan 2004)
New Revision: 5056
Removed:
trunk/gnue-appserver/src/classrep/crpopulate.py
Modified:
trunk/gnue-appserver/src/classrep/Base.py
trunk/gnue-appserver/src/classrep/Class.py
trunk/gnue-appserver/src/classrep/Definition.py
trunk/gnue-appserver/src/classrep/Module.py
trunk/gnue-appserver/src/classrep/Namespace.py
trunk/gnue-appserver/src/classrep/Procedure.py
trunk/gnue-appserver/src/classrep/Property.py
trunk/gnue-appserver/src/classrep/__init__.py
trunk/gnue-appserver/src/classrep/dtest.py
trunk/gnue-appserver/src/classrep/mtest.py
trunk/gnue-appserver/src/classrep/test.py
trunk/gnue-appserver/src/geasSession.py
trunk/gnue-appserver/src/geasSessionManager.py
trunk/gnue-appserver/src/language/Object.py
trunk/gnue-appserver/src/language/ObjectList.py
Log:
Rebuilt the classrepository. Language interface has no longer a cache.
Modified: trunk/gnue-appserver/src/classrep/Base.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Base.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/Base.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,30 +19,77 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Base.py,v 1.3 2003/10/21 12:26:50 jvetter Exp $
+# $Id$
import types
+from gnue.appserver.language import Object
+from Namespace import EClassRepository
# =============================================================================
# Class-wrapper for dictionaries
# =============================================================================
+
class BaseDictionary:
# ---------------------------------------------------------------------------
# Construct an instance
# ---------------------------------------------------------------------------
- def __init__ (self, session, defaultCache = None):
+ def __init__ (self, session, tablename, defaultItems = None):
self.session = session
- self._cache = {}
+ self.table = tablename
+ self._items = {}
- if defaultCache:
- self._cache = defaultCache
+ if defaultItems is not None:
+ self._items = defaultItems
# ---------------------------------------------------------------------------
+ # Reload the dictionary from the database by merging new records in
+ # ---------------------------------------------------------------------------
+ def reload (self):
+ list = self.session.find (self.table, self.getCondition (),
+ self.getSortorder (),
+ ['gnue_name'])
+ self.mergeIntoList (list)
+
+ # ---------------------------------------------------------------------------
+ # Merge a given object list with the dictionaries list
+ # ---------------------------------------------------------------------------
+ def mergeIntoList (self, addList):
+ for obj in addList:
+ found = 0
+
+ for item in self._items.values ():
+ if item.gnue_id == obj.gnue_id:
+ found = 1
+ break
+
+ if not found:
+ newItem = self.getNewItem (obj)
+ self._items [newItem.fullName] = newItem
+
+ # ---------------------------------------------------------------------------
+ # Return the conditions to be used on reload ()
+ # ---------------------------------------------------------------------------
+ def getCondition (self):
+ return []
+
+ # ---------------------------------------------------------------------------
+ # Return the sortorder to be used on reload ()
+ # ---------------------------------------------------------------------------
+ def getSortorder (self):
+ return ['gnue_id']
+
+ # ---------------------------------------------------------------------------
+ # Use getNewItem in derived classes to instanciate new dictionary-items
+ # ---------------------------------------------------------------------------
+ def getNewItem (self, obj):
+ raise EClassRepository ("%s: getNewItem() not implemented!" % self.table)
+
+ # ---------------------------------------------------------------------------
# Return all keys
# ---------------------------------------------------------------------------
def keys (self):
- keys = self._cache.keys ()
+ keys = self._items.keys ()
keys.sort ()
return keys
@@ -51,25 +98,25 @@
# ---------------------------------------------------------------------------
def values (self):
keys = self.keys ()
- return map (self._cache.get, keys)
+ return map (self._items.get, keys)
# ---------------------------------------------------------------------------
# Return all key-value-pairs
# ---------------------------------------------------------------------------
def items (self):
- return self._cache.items ()
+ return self._items.items ()
# ---------------------------------------------------------------------------
# Check for a specified key
# ---------------------------------------------------------------------------
def has_key (self, key):
- return self._cache.has_key (key)
+ return self._items.has_key (key)
# ---------------------------------------------------------------------------
# Return the number of items in the dictionary
# ---------------------------------------------------------------------------
def __len__ (self):
- return len (self._cache)
+ return len (self._items)
# ---------------------------------------------------------------------------
# Route class-access to the underlying dictionary
@@ -82,23 +129,49 @@
# This class maps all dictionary-keys to properties
# =============================================================================
class BaseObject:
- def __init__ (self, data):
- self._data = data
# ---------------------------------------------------------------------------
- # Undefined attributes must exist in data-dictionary
+ # Constructor
# ---------------------------------------------------------------------------
+ def __init__ (self, sessionManager, classname, object = None, pDefs = None):
+ self._sm = sessionManager
+ self.classname = classname
+ self._object = object
+
+ if pDefs is None:
+ self.predefined = {}
+ else:
+ self.predefined = pDefs
+
+ # ---------------------------------------------------------------------------
+ # Return an attributes value
+ # ---------------------------------------------------------------------------
def __getattr__ (self, attr):
- try:
- value = self._data [attr]
- if isinstance (value, types.UnicodeType):
- return value.encode ('utf-8')
- else:
- return value
+ if self._isPredefined (attr):
+ return self._getValue (self.predefined [attr])
+ else:
+ return self._getValue (getattr (self._getObject (), attr))
- except KeyError:
- raise AttributeError, attr
+ # ---------------------------------------------------------------------------
+ # Make sure unicode-type values will be encoded as utf-8
+ # ---------------------------------------------------------------------------
+ def _getValue (self, value):
+ if isinstance (value, types.UnicodeType):
+ return value.encode ('utf-8')
+ else:
+ return value
- except:
- raise
+ # ---------------------------------------------------------------------------
+ # Check wether an attribute is predefined or not
+ # ---------------------------------------------------------------------------
+ def _isPredefined (self, attr):
+ return self.predefined.has_key (attr)
+ # ---------------------------------------------------------------------------
+ # Get a language interface object
+ # ---------------------------------------------------------------------------
+ def _getObject (self):
+ if self._object is None:
+ self._object = Object (self._sm, 0, self.classname, self.gnue_id)
+ else:
+ return self._object
Modified: trunk/gnue-appserver/src/classrep/Class.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Class.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/Class.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Class.py,v 1.11 2003/11/08 18:43:28 siesel Exp $
+# $Id$
import types
from Base import *
@@ -35,44 +35,50 @@
# ---------------------------------------------------------------------------
# Create a dictionary with all classes [from a specified module]
# ---------------------------------------------------------------------------
- def __init__ (self, session, moduleDict, module = None, definition = None):
- BaseDictionary.__init__ (self, session)
+ def __init__ (self, sessionManager, session, moduleDict, module = None,
+ predefines = None):
+ BaseDictionary.__init__ (self, session, 'gnue_class')
+ self._sm = sessionManager
self.modules = moduleDict
self._module = module
- self.definition = definition
+ if predefines is not None:
+ for cDict in predefines.classes ():
+ cMod = self.modules.find (cDict ['gnue_module'])
+ proplist = predefines.properties (cDict ['gnue_id'])
- if not definition:
- self.definition = self.modules.definition
+ aClass = Class (self._sm, session, self, cMod, None, cDict, proplist)
+ self._items [aClass.fullName] = aClass
- # if we have an initial definition, use all it's classes
- if self.definition:
- list = [klass [1] for klass in self.definition.classes ()]
- self._updateCache (list)
-
# if a module is specified, fetch all it's classes
if module is not None:
if self.modules.classdict:
for item in self.modules.classdict.values ():
if item.module.fullName == module.fullName:
- self._cache [item.fullName] = item
+ self._items [item.fullName] = item
else:
- self._updateCache (self._requestData (module.gnue_id))
+ self.mergeIntoList (self._requestData (module.gnue_id))
- # otherwise preload the cache with all available classes !
- else:
- self._updateCache (self._requestData ())
# ---------------------------------------------------------------------------
- # Update the cache with all business objects in list
+ # Create a new instance for a dictionary-item
# ---------------------------------------------------------------------------
- def _updateCache (self, list):
- for item in list:
- klass = self._class_from_cache (item)
- self._cache [klass.fullName] = klass
+ def getNewItem (self, object):
+ module = self.modules.find (object.gnue_module)
+ return Class (self._sm, self.session, self, module, object)
# ---------------------------------------------------------------------------
+ # Get an apropriate reload ()-condition
+ # ---------------------------------------------------------------------------
+ def getCondition (self):
+ if self._module is not None:
+ return [["eq", ""], ["field", "gnue_module"],
+ ["const", self._module.gnue_id]]
+ else:
+ return []
+
+ # ---------------------------------------------------------------------------
# Request a list of matching business objects
# ---------------------------------------------------------------------------
def _requestData (self, moduleId = None, className = None):
@@ -91,22 +97,6 @@
["gnue_module", "gnue_name"])
# ---------------------------------------------------------------------------
- # Return an item from the cache using the ModuleDict for module verification
- # ---------------------------------------------------------------------------
- def _class_from_cache (self, item):
- module = self._module_from_cache (item)
- return Class (self, module, item)
-
- # ---------------------------------------------------------------------------
- # Return the module of a cached item
- # ---------------------------------------------------------------------------
- def _module_from_cache (self, item):
- for module in self.modules.values ():
- if module.gnue_id == item.gnue_module:
- return module
- raise EBadReference (item.gnue_name, "gnue_module")
-
- # ---------------------------------------------------------------------------
# Return a class object if it exists
# ---------------------------------------------------------------------------
def get (self, name):
@@ -114,15 +104,15 @@
module = self.modules [moduleName]
# is the class already cached ?
- if self._cache.has_key (name):
- return self._cache [name]
+ if self._items.has_key (name):
+ return self._items [name]
# since we had no match cached, ask for it
res = self._requestData (module.gnue_id, className)
if len (res) == 1:
- self._updateCache (res)
- return self._cache [name]
+ self._items [name] = self.getNewItem (res [0])
+ return self._items [name]
raise EClassNotFound (name)
@@ -131,34 +121,26 @@
# =============================================================================
# An implementation of a single class
# =============================================================================
-class Class:
+class Class (BaseObject):
# ---------------------------------------------------------------------------
# Wrapping a business object class
# ---------------------------------------------------------------------------
- def __init__ (self, classDict, module, object):
- self._object = object
- self.classes = classDict
+ def __init__ (self, sessionManager, session, classDict, module, object,
+ predefs = None, propDefList = None):
+ BaseObject.__init__ (self, sessionManager, 'gnue_class', object, predefs)
+
+ self.session = session
self.module = module
- self.definition = classDict.definition
self.fullName = createName (module.gnue_name, self.gnue_name)
self.table = self.fullName
+ self.classes = classDict
- self.properties = PropertyDict (classDict.session, classDict.modules, self)
- self.procedures = ProcedureDict (classDict.session, classDict.modules,
self)
+ self.properties = PropertyDict (self._sm, session, self, propDefList)
+ self.procedures = ProcedureDict (self._sm, session, self)
# ---------------------------------------------------------------------------
- # Attribute access is redirected into the gnue-namespace
- # ---------------------------------------------------------------------------
- def __getattr__ (self, attr):
- value = getattr (self._object, attr)
- if isinstance (value, types.UnicodeType):
- return value.encode ('utf-8')
- else:
- return value
-
- # ---------------------------------------------------------------------------
# Return a property by name
# ---------------------------------------------------------------------------
def findProp (self, name):
Modified: trunk/gnue-appserver/src/classrep/Definition.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Definition.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/Definition.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Definition.py,v 1.3 2003/09/19 09:00:48 reinhard Exp $
+# $Id$
import ConfigParser
import string
@@ -97,7 +97,7 @@
def modules (self):
res = []
for module in self._modules.keys ():
- res.append ((module, BaseObject (self._modules [module])))
+ res.append (self._modules [module])
return res
@@ -107,10 +107,10 @@
def classes (self, module = None):
res = []
for classname in self._classes.keys ():
- if module and splitName (classname) [0] <> module:
- continue
+ if (module is not None) and splitName (classname) [0] <> module:
+ continue
- res.append ((classname, BaseObject (self._classes [classname])))
+ res.append (self._classes [classname])
return res
@@ -120,10 +120,12 @@
def properties (self, klass = None):
res = []
for propname in self._properties.keys ():
- if klass and string.split (propname, '.') [0] <> klass:
- continue
+ if klass:
+ if string.split (propname, '.') [0] <> klass and \
+ self._properties [propname] ['gnue_class'] <> klass:
+ continue
- res.append ((propname, BaseObject (self._properties [propname])))
+ res.append (self._properties [propname])
return res
@@ -139,6 +141,7 @@
for m in x.modules ():
print m
+
print "\nClasses:"
for c in x.classes ():
print c
@@ -150,15 +153,12 @@
print "\n\n"
for p in x.properties ('gnue_module'):
- (key, obj) = p
- print "Key :", key
- print "Name:", obj.gnue_name
+ print "gnue_module::", p
- print [m [1] for m in x.modules ()]
- mmod = x.modules () [0][1]
- print mmod._data.keys ()
-
print "----"
print x.classes ('gnue')
+
+ print "=============="
+ print x.properties ('00000000000000000000000000000010')
Modified: trunk/gnue-appserver/src/classrep/Module.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Module.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/Module.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Module.py,v 1.9 2003/10/21 12:26:50 jvetter Exp $
+# $Id$
import types
from Base import *
@@ -35,39 +35,23 @@
# This class behaves like a dictionary of all available modules with the
# keys being the module names and the values being Module objects.
# ---------------------------------------------------------------------------
- def __init__ (self, session, definition = None):
- BaseDictionary.__init__ (self, session)
- self.definition = definition
- self.classdict = None
+ def __init__ (self, sessionManager, session, predefines = None):
+ BaseDictionary.__init__ (self, session, 'gnue_module')
- if definition:
- self._updateCache ([module [1] for module in definition.modules ()])
- else:
- self._updateCache (self._requestData ())
+ self._sm = sessionManager
- # ---------------------------------------------------------------------------
- # Integrate a list of business objects into the cache
- # ---------------------------------------------------------------------------
- def _updateCache (self, list):
- for item in list:
- module = self._module_from_cache (item)
- self._cache [module.fullName] = module
+ # Note: this 'predefines' is a RepositoryDefinition
+ if predefines is not None:
+ for mDict in predefines.modules ():
+ module = Module (self._sm, self.session, self, None, mDict)
+ self._items [module.fullName] = module
- # ---------------------------------------------------------------------------
- # Internal: Request modules from datasource (optional matching a name)
- # ---------------------------------------------------------------------------
- def _requestData (self, name = None):
- cond = []
- if name:
- cond = [["eq", ""], ["field", "gnue_name"], ["const", name]]
- return self.session.find ("gnue_module", cond, ["gnue_name"],
- ["gnue_name", "gnue_id"])
# ---------------------------------------------------------------------------
- # Internal: create an instance from a cached object
+ # Create a new module instance
# ---------------------------------------------------------------------------
- def _module_from_cache (self, item):
- return Module (self, item)
+ def getNewItem (self, object):
+ return Module (self._sm, self.session, self, object)
# ---------------------------------------------------------------------------
# Return a Module object if the given module exists
@@ -75,30 +59,43 @@
def get (self, name):
# is the requested module cached?
if self.has_key (name):
- return self._cache [name]
+ return self._items [name]
# since it isn't cached we've to ask for it
- list = self._requestData (name)
+ cond = [["eq", ""], ["field", "gnue_name"], ["const", name]]
+ list = self.session.find ("gnue_module", cond, ["gnue_name"],
+ ["gnue_name", "gnue_id"])
# if we have an exact match extend the cache
if len (list) == 1:
- self._updateCache (list)
- return self._cache [name]
+ self._items [name] = self.getNewItem (list [0])
+ return self._items [name]
raise EModuleNotFound (name)
+ # ---------------------------------------------------------------------------
+ # Find a listed module by its id
+ # ---------------------------------------------------------------------------
+ def find (self, moduleId):
+ for mod in self.values ():
+ if mod.gnue_id == moduleId:
+ return mod
+ return None
# =============================================================================
# A Business Object Module
# =============================================================================
-class Module:
+class Module (BaseObject):
- def __init__ (self, modDict, object):
- # _object is the underlying business object
- self.modules = modDict
- self._object = object
+ # ---------------------------------------------------------------------------
+ # Constructor
+ # ---------------------------------------------------------------------------
+ def __init__ (self, sessionManager, session, mDict, object=None, pDefs=None):
+ BaseObject.__init__ (self, sessionManager, 'gnue_module', object, pDefs)
+ self.session = session
+ self.modules = mDict
self.fullName = self.gnue_name
# ---------------------------------------------------------------------------
@@ -106,13 +103,11 @@
# ---------------------------------------------------------------------------
def __getattr__ (self, attr):
if attr == 'classes':
- self.__dict__ ['classes'] = ClassDict (self.modules.session,
+ self.__dict__ ['classes'] = ClassDict (self._sm, self.session,
self.modules, self)
+ # Make sure the created class-dictionary is up to date
+ self.classes.reload ()
return self.classes
-
else:
- value = getattr (self._object, attr)
- if isinstance (value, types.UnicodeType):
- return value.encode ('utf-8')
- else:
- return value
+ return BaseObject.__getattr__ (self, attr)
+
Modified: trunk/gnue-appserver/src/classrep/Namespace.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Namespace.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/Namespace.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Namespace.py,v 1.4 2003/10/19 22:08:04 reinhard Exp $
+# $Id$
import string
@@ -76,6 +76,14 @@
EClassRepository.__init__ (self, msg)
# =============================================================================
+# Requested property does not exist
+# =============================================================================
+class EProcedureNotFound (EClassRepository):
+ def __init__ (self, classname, procedure):
+ msg = "Class '%s' has no procedure '%s'." % (classname, procedure)
+ EClassRepository.__init__ (self, msg)
+
+# =============================================================================
# Class repository definition file has an invalid structure
# =============================================================================
class EInvalidDefinition (EClassRepository):
Modified: trunk/gnue-appserver/src/classrep/Procedure.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Procedure.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/Procedure.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Procedure.py,v 1.2 2003/11/09 23:40:41 siesel Exp $
+# $Id$
import types
from Base import *
@@ -30,46 +30,37 @@
# =============================================================================
class ProcedureDict (BaseDictionary):
+ #
+ # TODO: find a good place to call a ProcedureDict.reload () automatically
+ #
+
# ---------------------------------------------------------------------------
# Construct a Procedure-Dictionary for class klass
# ---------------------------------------------------------------------------
- def __init__ (self, session, moduleDict, klass, definition = None):
- BaseDictionary.__init__ (self, session)
+ def __init__ (self, sessionManager, session, klass, predefs = None):
+ BaseDictionary.__init__ (self, session, 'gnue_procedure')
- self.modules = moduleDict
+ self._sm = sessionManager
self.klass = klass
- self.definition = definition
+ self.module = klass.module
- if not self.definition:
- self.definition = klass.definition
+ # ---------------------------------------------------------------------------
+ # Create a new instance of a dictionary item
+ # ---------------------------------------------------------------------------
+ def getNewItem (self, object):
+ pMod = self.module.modules.find (object.gnue_module)
+ return Procedure (self._sm, pMod, self.klass, object)
- if not self.definition:
- self.definition = moduleDict.definition
-
- if self.definition:
- list = [prop [1] for prop in self.definition.properties (klass.fullName)]
- self._updateCache (list)
-
- self._updateCache (self._requestData (self.klass.gnue_id))
-
# ---------------------------------------------------------------------------
- # Update cache with all business objects in list
+ # A reload () returns only the procedures of the class
# ---------------------------------------------------------------------------
- def _updateCache (self, list):
- for item in list:
- procedure = self._procedure_from_cache (item)
- self._cache [procedure.fullName] = procedure
+ def getCondition (self):
+ return [["eq", ""], ["field", "gnue_class"], ["const", self.klass.gnue_id]]
# ---------------------------------------------------------------------------
# Read a list of properties from the datasource
# ---------------------------------------------------------------------------
def _requestData (self, classId, procedureName = None):
- # Special case: if there is already a procedure with a matching class id
- # we assume all properties of the requesed class are already cached
- for prop in self.values ():
- if prop.gnue_class == classId:
- return []
-
cond = [["eq", ""], ["field", "gnue_class"], ["const", classId]]
if procedureName:
@@ -81,38 +72,21 @@
"gnue_comment"])
# ---------------------------------------------------------------------------
- # Get a procedure from the cache
- # ---------------------------------------------------------------------------
- def _procedure_from_cache (self, item):
- return Procedure (self._module_from_cache (item), self.klass, item)
-
- # ---------------------------------------------------------------------------
- # Get a module from a cache-item
- # ---------------------------------------------------------------------------
- def _module_from_cache (self, item):
- for module in self.modules.values ():
- if module.gnue_id == item.gnue_module:
- return module
- raise EBadReference (item.gnue_name, "gnue_module")
-
-
- # ---------------------------------------------------------------------------
# Return a Procedure object if it exists
# ---------------------------------------------------------------------------
def get (self, name):
- (moduleName, propName) = splitName (name)
- module = self.modules [moduleName]
+ (moduleName, procName) = splitName (name)
# is the procedure already cached
if self.has_key (name):
- return self._cache [name]
+ return self._items [name]
# since we had no match in the cache ask for it
- res = self._requestData (self.klass.gnue_id, name)
+ res = self._requestData (self.klass.gnue_id, procName)
if len (res) == 1:
- self._updateCache (res)
- return self._cache [name]
+ self._items [name] = self.getNewItem (res [0])
+ return self._items [name]
raise EProcedureNotFound (self.klass.fullName, name)
@@ -120,25 +94,17 @@
# =============================================================================
# A Business Object Procedure
# =============================================================================
-class Procedure:
+class Procedure (BaseObject):
# ---------------------------------------------------------------------------
# Construct a new procedure from module, class and business object
# ---------------------------------------------------------------------------
- def __init__ (self, module, klass, object):
- self.module = module
+ def __init__ (self, sessionManager, module, klass, object, pDefs = None):
+ BaseObject.__init__ (self, sessionManager, 'gnue_procedure', object, pDefs)
+
self.klass = klass
- self._object = object
+ self.module = module
# gnue_procedure.gnue_name is already a fully qualified identifier
self.fullName = createName (module.gnue_name, self.gnue_name)
- # ---------------------------------------------------------------------------
- # all unknown attributes are routed to the gnue-namespace
- # ---------------------------------------------------------------------------
- def __getattr__ (self, attr):
- value = getattr (self._object, attr)
- if isinstance (value, types.UnicodeType):
- return value.encode ('utf-8')
- else:
- return value
Modified: trunk/gnue-appserver/src/classrep/Property.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Property.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/Property.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: Property.py,v 1.9 2003/10/19 22:08:04 reinhard Exp $
+# $Id$
import types
from Base import *
@@ -33,32 +33,33 @@
# ---------------------------------------------------------------------------
# Construct a Property-Dictionary for class klass
# ---------------------------------------------------------------------------
- def __init__ (self, session, moduleDict, klass, definition = None):
- BaseDictionary.__init__ (self, session)
+ def __init__ (self, sessionManager, session, klass, predefs = None):
+ BaseDictionary.__init__ (self, session, 'gnue_property')
- self.modules = moduleDict
+ self._sm = sessionManager
self.klass = klass
- self.definition = definition
+ self.module = klass.module
- if not self.definition:
- self.definition = klass.definition
+ if predefs is not None:
+ for pDef in predefs:
+ pMod = self.module.modules.find (pDef ['gnue_module'])
+ prop = Property (self._sm, pMod, self.klass, None, pDef)
+ self._items [prop.fullName] = prop
+ else:
+ self.reload ()
- if not self.definition:
- self.definition = moduleDict.definition
+ # ---------------------------------------------------------------------------
+ # Create a new instance of a dictionary item
+ # ---------------------------------------------------------------------------
+ def getNewItem (self, object):
+ pMod = self.module.modules.find (object.gnue_module)
+ return Property (self._sm, pMod, self.klass, object)
- if self.definition:
- list = [prop [1] for prop in self.definition.properties (klass.fullName)]
- self._updateCache (list)
-
- self._updateCache (self._requestData (self.klass.gnue_id))
-
# ---------------------------------------------------------------------------
- # Update cache with all business objects in list
+ # Restrict a reload () to the classes properties
# ---------------------------------------------------------------------------
- def _updateCache (self, list):
- for item in list:
- property = self._property_from_cache (item)
- self._cache [property.fullName] = property
+ def getCondition (self):
+ return [["eq", ""], ["field", "gnue_class"], ["const", self.klass.gnue_id]]
# ---------------------------------------------------------------------------
# Read a list of properties from the datasource
@@ -81,38 +82,19 @@
"gnue_comment"])
# ---------------------------------------------------------------------------
- # Get a property from the cache
- # ---------------------------------------------------------------------------
- def _property_from_cache (self, item):
- return Property (self._module_from_cache (item), self.klass, item)
-
- # ---------------------------------------------------------------------------
- # Get a module from a cache-item
- # ---------------------------------------------------------------------------
- def _module_from_cache (self, item):
- for module in self.modules.values ():
- if module.gnue_id == item.gnue_module:
- return module
- raise EBadReference (item.gnue_name, "gnue_module")
-
-
- # ---------------------------------------------------------------------------
# Return a Property object if it exists
# ---------------------------------------------------------------------------
def get (self, name):
- (moduleName, propName) = splitName (name)
- module = self.modules [moduleName]
-
# is the property already cached
if self.has_key (name):
- return self._cache [name]
+ return self._items [name]
# since we had no match in the cache ask for it
res = self._requestData (self.klass.gnue_id, name)
if len (res) == 1:
- self._updateCache (res)
- return self._cache [name]
+ self._items [name] = self.getNewItem (res [0])
+ return self._items [name]
raise EPropertyNotFound (self.klass.fullName, name)
@@ -120,19 +102,22 @@
# =============================================================================
# A Business Object Property
# =============================================================================
-class Property:
+class Property (BaseObject):
# ---------------------------------------------------------------------------
# Construct a new property from module, class and business object
# ---------------------------------------------------------------------------
- def __init__ (self, module, klass, object):
- self.module = module
+ def __init__ (self, sessionManager, module, klass, object, pDefs = None):
+
+ BaseObject.__init__ (self, sessionManager, 'gnue_property', object, pDefs)
+
self.klass = klass
- self._object = object
+ self.module = module
# gnue_property.gnue_name is already a fully qualified identifier
- self.fullName = createName (module.gnue_name, self.gnue_name)
+ self.fullName = createName (self.module.gnue_name, self.gnue_name)
self.column = self.fullName
+
if self.gnue_type == 'string':
self.fullType = '%s(%d)' % (self.gnue_type, int (self.gnue_length))
elif self.gnue_type == 'number':
@@ -143,13 +128,3 @@
int (self.gnue_scale))
else:
self.fullType = self.gnue_type
-
- # ---------------------------------------------------------------------------
- # all unknown attributes are routed to the gnue-namespace
- # ---------------------------------------------------------------------------
- def __getattr__ (self, attr):
- value = getattr (self._object, attr)
- if isinstance (value, types.UnicodeType):
- return value.encode ('utf-8')
- else:
- return value
Modified: trunk/gnue-appserver/src/classrep/__init__.py
===================================================================
--- trunk/gnue-appserver/src/classrep/__init__.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/__init__.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: __init__.py,v 1.14 2003/10/21 12:26:50 jvetter Exp $
+# $Id$
import os, sys
@@ -34,11 +34,7 @@
# Global module and class list
# -----------------------------------------------------------------------------
-modules = None
-classes = None
-
def init (server):
- global modules, classes
# First, load the hardwired default repository
try:
@@ -49,14 +45,17 @@
basedir = os.path.join (paths.data, "share", "gnue", "appserver")
defaultRepository = os.path.join (basedir, "repository.ini")
- modules = ModuleDict (None, RepositoryDefinition (defaultRepository))
- classes = ClassDict (None, modules)
- # Now, we can access the database to load the real repository
session = Session.InternalSession (server)
- new_modules = ModuleDict (session)
- new_classes = ClassDict (session, new_modules)
- modules = new_modules
- classes = new_classes
- modules.classdict = classes
+
+ # Create a boot-catalogue from the ini-file
+ bootcat = RepositoryDefinition (defaultRepository)
+
+ server.modules = ModuleDict (server, session, bootcat)
+ server.classes = ClassDict (server, session, server.modules, None, bootcat)
+ server.modules.classdict = server.classes
+
+ server.modules.reload ()
+ server.classes.reload ()
+
return
Deleted: trunk/gnue-appserver/src/classrep/crpopulate.py
===================================================================
--- trunk/gnue-appserver/src/classrep/crpopulate.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/classrep/crpopulate.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -1,96 +0,0 @@
-#
-# Populate the database with class repository definition
-#
-
-from language import App
-from Namespace import *
-from gnue.appserver import classrep
-
-# First we have to create a session from the language interface
-app = App.App ()
-lSession = app.newSession ("hacker", "secret")
-
-# Now load the initial class repository
-print "Loading repository definition ..."
-crdef = classrep.RepositoryDefinition ('classrep/repository.ini')
-
-
-print "Retrieving existing modules ..."
-modules = lSession.find ('gnue_module')
-
-for moduleDef in crdef.modules ():
-
- if moduleDef [0] in [cmod.gnue_name for cmod in modules]:
- newModule = None
-
- for cmod in modules:
- if cmod.gnue_name == moduleDef [0]:
- newModule = cmod
- break
- print "Using:", newModule.gnue_name, newModule.gnue_id
-
- else:
- print "Building new module:", moduleDef [0]
-
- newModule = lSession.new ('gnue_module')
- newModule.gnue_name = moduleDef [1].gnue_name
- newModule.gnue_comment = moduleDef [1].gnue_comment
- newModule.store ()
- print "Stored %s as %s" % (newModule.gnue_name, newModule.objectId)
-
- print "Retrieving classes of '%s' ..." % moduleDef [0]
- classes = lSession.find ('gnue_class',
- [["eq", ""], ["field", "gnue_module"], ["const", newModule.objectId]])
- kllist = [createName (newModule.gnue_name, kl.gnue_name) for kl in classes]
-
- # Adding all classes of 'newModule'
- for clDef in crdef.classes (newModule.gnue_name):
- # since we need the classes property-dictionary later, we require the
- # class-dictionary here (using the apropriate module-id).
- aClass = classrep.classes [clDef [0]]
- aClass.gnue_module = newModule.objectId
-
- if clDef [0] in kllist:
- newClass = None
- for klass in classes:
- if createName (newModule.gnue_name, klass.gnue_name) == clDef [0]:
- newClass = klass
- break
-
- print "Using class:", newClass.gnue_name, newClass.objectId
-
- else:
- print "Building new class:", clDef [0]
- newClass = lSession.new ('gnue_class')
- newClass.gnue_module = aClass.gnue_module
- newClass.gnue_name = aClass.gnue_name
- newClass.gnue_comment = aClass.gnue_comment
- newClass.store ()
- print "Stored %s as %s" % (newClass.gnue_name, newClass.objectId)
-
- print "Retrieving properties of '%s' ..." % clDef [0]
- plist = lSession.find ('gnue_property',
- [["eq", ""], ["field", "gnue_class"], ["const", newClass.objectId],
- ["eq", ""], ["field", "gnue_module"], ["const", aClass.gnue_module]])
- properties = [pr.gnue_name for pr in plist]
-
- for prop in aClass.properties.values ():
- if prop.fullName in properties:
- continue
-
- print "Adding property:", prop.fullName
-
- newProp = lSession.new ('gnue_property')
- newProp.gnue_class = newClass.objectId
- newProp.gnue_module = aClass.gnue_module
- newProp.gnue_name = prop.gnue_name
- newProp.gnue_comment = prop.gnue_comment
- newProp.gnue_length = prop.gnue_length
- newProp.gnue_type = prop.gnue_type
- newProp.gnue_precision = prop.gnue_precision
- newProp.store ()
-
-
- print "Committing module '%s' ..." % newModule.gnue_name
- lSession.commit ()
-
Modified: trunk/gnue-appserver/src/classrep/dtest.py
===================================================================
--- trunk/gnue-appserver/src/classrep/dtest.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/dtest.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,46 +19,50 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: dtest.py,v 1.5 2003/09/22 11:53:01 jvetter Exp $
+# $Id$
#
-from language import App
from gnue.appserver import classrep
+from gnue.appserver.test import testApp
+
from Definition import *
-app = App.App ()
+app = testApp ()
+sm = app.getSessionManager ()
print "Requesting class 'gnue_property'\n"
-klass = classrep.classes ["gnue_property"]
+klass = sm.classes ["gnue_property"]
print "\n"
print "Requesting class 'address_person'\n"
# -------------
-klass = classrep.classes ["address_person"]
+klass = sm.classes ["address_person"]
print "Name = %s, Comment = %s, Fullname = %s\n" % (klass.gnue_name,
klass.gnue_comment, klass.fullName)
print "Number of properties in class: %d" % len (klass.properties)
+print "Properties:"
for p in klass.properties.keys ():
pObj = klass.properties [p]
print "Property %s: %s (%s)" % (pObj.gnue_name, pObj.gnue_type,
pObj.gnue_comment)
+print "End of properties"
-klass = classrep.classes ["gnue_module"]
+klass = sm.classes ["gnue_module"]
print "Number of properties in %s: %d" % (klass.fullName,
len (klass.properties))
-# print classrep.Classes.keys ()
+# print sm.Classes.keys ()
# -----------------
print "Now it should come faster (cached):\n"
-klass = classrep.classes ["address_person"]
+klass = sm.classes ["address_person"]
print "Name = %s, Comment = %s, Fullname = %s\n" % (klass.gnue_name,
klass.gnue_comment, klass.fullName)
@@ -73,7 +77,7 @@
# ---- gnue_*
print "Fetching gnue_class :)"
-gclass = classrep.classes ["gnue_class"]
+gclass = sm.classes ["gnue_class"]
print "Name = %s (full:%s) Comment = %s" % (gclass.gnue_name, gclass.fullName,
gclass.gnue_comment)
Modified: trunk/gnue-appserver/src/classrep/mtest.py
===================================================================
--- trunk/gnue-appserver/src/classrep/mtest.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/mtest.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,23 +19,24 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: mtest.py,v 1.4 2003/09/18 15:14:10 jvetter Exp $
+# $Id$
#
# This testing unit dumps some values of class definitions.
#
-from language import App
-from gnue.appserver import classrep
+# from gnue.appserver import classrep
+from gnue.appserver.test import testApp
# First we have to create a session from the language interface
-app = App.App ()
+app = testApp ()
+sm = app.getSessionManager ()
# -----------------------------------------------------------------------------
# Dump some values of a class definition
# -----------------------------------------------------------------------------
def dumpClass (aName):
print "\nRequesting class '%s' ..." % aName
- aClass = classrep.classes [aName]
+ aClass = sm.classes [aName]
print "Fullname:", aClass.fullName
print "Id :", aClass.gnue_id
@@ -58,7 +59,7 @@
dumpClass ('gnue_class')
print "Searching for property 'gnue_name' in class 'gnue_property' ..."
-x = classrep.classes ['gnue_property']
+x = sm.classes ['gnue_property']
y = x.findProp ('gnue_name')
print "Fullname:", y.fullName
print "Module :", y.klass.module.fullName
Modified: trunk/gnue-appserver/src/classrep/test.py
===================================================================
--- trunk/gnue-appserver/src/classrep/test.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/classrep/test.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: test.py,v 1.8 2003/10/21 12:26:50 jvetter Exp $
+# $Id$
#
from gnue.appserver.language import App
@@ -33,8 +33,11 @@
print "Already loaded modules:", sm.modules.keys ()
print "Already loaded classes:", sm.classes.keys ()
+print "Modules:", sm.modules.values ()
+
print '\nModule "address":'
m = sm.modules ["address"]
+# m = sm.modules ["gnue"]
print "%s: %s\n" % (m.gnue_name, m.gnue_comment)
print "Classes in 'address':"
@@ -45,6 +48,12 @@
print cl.fullName + "." + p
print "-" * 50
+print "Procedures of 'address_person':"
+ap = m.classes ['address_person']
+ap.procedures.reload ()
+for pr in ap.procedures.values ():
+ print "%s coded in %s" % (pr.fullName, pr.gnue_language)
+
print "Number of modules: %d\n" % len (sm.modules)
print "All modules via keys ():"
Modified: trunk/gnue-appserver/src/geasSession.py
===================================================================
--- trunk/gnue-appserver/src/geasSession.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/geasSession.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -19,10 +19,9 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: geasSession.py,v 1.40 2003/10/19 16:45:16 reinhard Exp $
+# $Id$
import geasList
-import classrep
import whrandom
# =============================================================================
@@ -98,7 +97,7 @@
if not self._authAdapter.hasAccess (self, self._user, classname):
raise Exception, "Access to class '%s' denied" % classname
- classdef = classrep.classes [classname]
+ classdef = self.sm.classes [classname]
# create new List
return geasList.geasList (self, classdef, propertylist, sortorder)
@@ -174,7 +173,7 @@
result = []
for object_id in obj_id_list:
if object_id == "":
- classdef = classrep.classes [classname]
+ classdef = self.sm.classes [classname]
result.append ([classdef.properties[p].fullType for p in propertylist])
else:
instance = list.find (object_id)
Modified: trunk/gnue-appserver/src/geasSessionManager.py
===================================================================
--- trunk/gnue-appserver/src/geasSessionManager.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/geasSessionManager.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -19,7 +19,7 @@
#
# Copyright 2001-2004 Free Software Foundation
#
-# $Id: geasSessionManager.py,v 1.17 2003/10/21 12:26:49 jvetter Exp $
+# $Id$
import geasSession
import geasAuthentication
@@ -48,8 +48,6 @@
self._sessions = {}
self._buildInternalSession ()
classrep.init (self)
- self.modules = classrep.modules
- self.classes = classrep.classes
# TODO: load default authagent depending on config setting
self._authAdapter = geasAuthentication.geasDBAuthAgent
(self._internalSession)
Modified: trunk/gnue-appserver/src/language/Object.py
===================================================================
--- trunk/gnue-appserver/src/language/Object.py 2004-01-30 09:54:32 UTC (rev
5055)
+++ trunk/gnue-appserver/src/language/Object.py 2004-01-30 13:27:47 UTC (rev
5056)
@@ -74,16 +74,20 @@
if self.objectId:
res = self._server.load (self._session_id, self._class,
[self.objectId, ''], [attr])
- self._cache [attr] = self.rpc_to_native (res [0] [0], res [1] [0])
+ # self._cache [attr] = self.rpc_to_native (res [0] [0], res [1] [0])
+ return self.rpc_to_native (res [0] [0], res [1] [0])
else:
res = self._server.load (self._session_id, self._class, [''], [attr])
- self._cache [attr] = self.rpc_to_native (None, res [0] [0])
+ # self._cache [attr] = self.rpc_to_native (None, res [0] [0])
+ return self.rpc_to_native (None, res [0] [0])
+
elif self._attrIsMethod (attr):
return Procedure (self._server, self._session_id, self.objectId,
self._class, attr)
else:
raise AttributeError, attr
+ print "ERR: %s.%s" % (self._class, attr)
return self._cache [attr]
Modified: trunk/gnue-appserver/src/language/ObjectList.py
===================================================================
--- trunk/gnue-appserver/src/language/ObjectList.py 2004-01-30 09:54:32 UTC
(rev 5055)
+++ trunk/gnue-appserver/src/language/ObjectList.py 2004-01-30 13:27:47 UTC
(rev 5056)
@@ -97,15 +97,16 @@
rset = self._server.fetch (self._session_id, self.list_id,
len (self._cache), CACHE_STEP, 0)
for row in rset:
- ## Convert array into dictonary
- i = 0
- objData = {}
+ # Just keep the 'gnue_id' property cached
+ objData = {"gnue_id": row [0]}
+ # i = 0
+ # objData = {}
- for p in self.properties:
- objData [p] = row [i+1]
- i += 1
+ # for p in self.properties:
+ # objData [p] = row [i+1]
+ # i += 1
- objData ["gnue_id"] = row [0]
+ # objData ["gnue_id"] = row [0]
obj = Object (self._server, self._session_id, self.classname, objData)
self._cache.append (obj)
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- r5056 - in trunk/gnue-appserver/src: . classrep language,
johannes <=