Skip to content

Z
Zope
Commit e1276ff7 authored by Hanno Schlichting's avatar Hanno Schlichting
Browse files
Options

Removed the last remaining code to support `SOFTWARE_HOME` and `ZOPE_HOME`.

parent 31b6b4d9
Hide whitespace changes
Inline Side-by-side
Showing with 11 additions and 624 deletions
doc/CHANGES.rst
View file @ e1276ff7
......@@ -41,6 +41,8 @@ Features Added
Restructuring
+++++++++++++
- Removed the last remaining code to support `SOFTWARE_HOME` and `ZOPE_HOME`.
- Removed ZMI controls for restarting the process, these no longer apply when
managed as a WSGI application.
......
src/App/ApplicationManager.py
View file @ e1276ff7
......@@ -239,8 +239,6 @@ class DebugManager(Item, Implicit):
InitializeClass(DebugManager)
class ApplicationManager(Folder, CacheManager):
"""System management
"""
......@@ -350,41 +348,6 @@ class ApplicationManager(Folder, CacheManager):
REQUEST['URL1'] + '/manage_workspace')
return t
def revert_points(self):
return ()
def version_list(self):
# Return a list of currently installed products/versions
cfg = getConfiguration()
product_dir = os.path.join(cfg.softwarehome,'Products')
product_names = os.listdir(product_dir)
product_names.sort()
info = []
for product_name in product_names:
package_dir = os.path.join(product_dir, product_name)
if not os.path.isdir(package_dir):
continue
version_txt = None
for name in ('VERSION.TXT', 'VERSION.txt', 'version.txt'):
v = os.path.join(package_dir, name)
if os.path.exists(v):
version_txt = v
break
if version_txt is not None:
file = open(version_txt, 'r')
data = file.readline()
file.close()
info.append(data.strip())
return info
def getSOFTWARE_HOME(self):
cfg = getConfiguration()
return getattr(cfg, 'softwarehome', None)
def getZOPE_HOME(self):
cfg = getConfiguration()
return getattr(cfg, 'zopehome', None)
def getINSTANCE_HOME(self):
return getConfiguration().instancehome
......@@ -406,22 +369,6 @@ class ApplicationManager(Folder, CacheManager):
l.append((str(type), 'Port: %s' % port))
return l
def objectIds(self, spec=None):
""" this is a patch for pre-2.4 Zope installations. Such
installations don't have an entry for the WebDAV LockManager
introduced in 2.4.
"""
meta_types = map(lambda x: x.get('meta_type', None), self._objects)
if not self.DavLocks.meta_type in meta_types:
lst = list(self._objects)
lst.append({'id': 'DavLocks',
'meta_type': self.DavLocks.meta_type})
self._objects = tuple(lst)
return Folder.objectIds(self, spec)
class AltDatabaseManager(DatabaseManager, CacheManager):
""" Database management DBTab-style
......
src/App/Extensions.py
View file @ e1276ff7
......@@ -12,7 +12,7 @@
##############################################################################
"""Standard routines for handling extensions.
Extensions currently include external methods and pluggable brains.
Extensions currently include external methods.
"""
import imp
import os
......@@ -90,7 +90,6 @@ def getPath(prefix, name, checkProduct=1, suffixes=('',), cfg=None):
raise ValueError('The file name, %s, should be a simple file name'
% name)
result = None
if checkProduct:
dot = name.find('.')
if dot > 0:
......@@ -113,11 +112,6 @@ def getPath(prefix, name, checkProduct=1, suffixes=('',), cfg=None):
locations = [cfg.instancehome]
softwarehome = getattr(cfg, 'softwarehome', None)
if softwarehome is not None:
zopehome = os.path.dirname(softwarehome)
locations.append(zopehome)
for home in locations:
found = _getPath(home, prefix, name, suffixes)
if found is not None:
......@@ -202,23 +196,3 @@ def getObject(module, name, reload=0,
except KeyError:
raise NotFound("The specified object, '%s', was not found "
"in module, '%s'." % (name, module))
class NoBrains:
pass
def getBrain(module, class_name, reload=0, modules=None):
""" Check/load a class from an extension.
"""
if not module and not class_name:
return NoBrains
if modules is None:
c=getObject(module, class_name, reload)
else:
c=getObject(module, class_name, reload, modules=modules)
if getattr(c, '__bases__', None) is None:
raise ValueError('%s, is not a class' % class_name)
return c
src/App/FindHomes.py
View file @ e1276ff7
......@@ -18,22 +18,6 @@ import sys
import Products
try:
home = os.environ['SOFTWARE_HOME']
except KeyError:
pass
else:
home = os.path.realpath(home)
__builtin__.SOFTWARE_HOME = SOFTWARE_HOME = home
try:
zhome = os.environ['ZOPE_HOME']
except KeyError:
pass
else:
zhome = os.path.realpath(zhome)
__builtin__.ZOPE_HOME = ZOPE_HOME = zhome
try:
chome = os.environ['INSTANCE_HOME']
except KeyError:
......
src/App/ImageFile.py
View file @ e1276ff7
......@@ -47,7 +47,7 @@ class ImageFile(Explicit):
def __init__(self, path, _prefix=None):
if _prefix is None:
_prefix=getattr(getConfiguration(), 'softwarehome', None) or PREFIX
_prefix = PREFIX
if not os.path.isabs(path):
warnings.warn(NON_PREFIX_WARNING, UserWarning, 2)
elif type(_prefix) is not type(''):
......
src/App/config.py
View file @ e1276ff7
......@@ -52,16 +52,6 @@ def setConfiguration(cfg):
os.environ["INSTANCE_HOME"] = cfg.instancehome
Globals.INSTANCE_HOME = cfg.instancehome
if hasattr(cfg, 'softwarehome') and cfg.softwarehome is not None:
__builtin__.SOFTWARE_HOME = FindHomes.SOFTWARE_HOME = cfg.softwarehome
os.environ["SOFTWARE_HOME"] = cfg.softwarehome
Globals.SOFTWARE_HOME = cfg.softwarehome
if hasattr(cfg, 'zopehome') and cfg.zopehome is not None:
__builtin__.ZOPE_HOME = FindHomes.ZOPE_HOME = cfg.zopehome
os.environ["ZOPE_HOME"] = cfg.zopehome
Globals.ZOPE_HOME = cfg.zopehome
Globals.DevelopmentMode = cfg.debug_mode
class DefaultConfiguration:
......@@ -72,10 +62,6 @@ class DefaultConfiguration:
from App import FindHomes
self.clienthome = FindHomes.CLIENT_HOME
self.instancehome = FindHomes.INSTANCE_HOME
if hasattr(FindHomes, 'SOFTWARE_HOME'):
self.softwarehome = FindHomes.SOFTWARE_HOME
if hasattr(FindHomes, 'ZOPE_HOME'):
self.zopehome = FindHomes.ZOPE_HOME
self.dbtab = None
self.debug_mode = True
self.enable_product_installation = False
......
src/App/special_dtml.py
View file @ e1276ff7
......@@ -45,7 +45,7 @@ class ClassicHTMLFile(DocumentTemplate.HTMLFile,MethodObject.Method,):
def __init__(self, name, _prefix=None, **kw):
if _prefix is None:
_prefix = getattr(getConfiguration(), 'softwarehome', PREFIX)
_prefix = PREFIX
elif type(_prefix) is not type(''):
_prefix = Common.package_home(_prefix)
args=(self, os.path.join(_prefix, name + '.dtml'))
......
src/App/tests/test_ApplicationManager.py
View file @ e1276ff7
......@@ -414,50 +414,6 @@ class ApplicationManagerTests(ConfigTestBase,
am = self._makeOne()
self.assertEqual(am.thread_get_ident(), thread.get_ident())
def test_revert_points(self):
am = self._makeOne()
self.assertEqual(list(am.revert_points()), [])
def test_version_list(self):
# XXX this method is too stupid to live: returning a bare list
# of versions without even tying them to the products?
# and what about products living outside SOFTWARE_HOME?
# Nobody calls it, either
import os
am = self._makeOne()
config = self._makeConfig()
swdir = config.softwarehome = self._makeTempdir()
foodir = os.path.join(swdir, 'Products', 'foo')
self._makeFile(foodir, 'VERSION.TXT', '1.2')
bardir = os.path.join(swdir, 'Products', 'bar')
self._makeFile(bardir, 'VERSION.txt', '3.4')
bazdir = os.path.join(swdir, 'Products', 'baz')
self._makeFile(bazdir, 'version.txt', '5.6')
versions = am.version_list()
self.assertEqual(versions, ['3.4', '5.6', '1.2'])
def test_getSOFTWARE_HOME_missing(self):
am = self._makeOne()
config = self._makeConfig()
self.assertEqual(am.getSOFTWARE_HOME(), None)
def test_getSOFTWARE_HOME_present(self):
am = self._makeOne()
config = self._makeConfig()
swdir = config.softwarehome = self._makeTempdir()
self.assertEqual(am.getSOFTWARE_HOME(), swdir)
def test_getZOPE_HOME_missing(self):
am = self._makeOne()
config = self._makeConfig()
self.assertEqual(am.getZOPE_HOME(), None)
def test_getZOPE_HOME_present(self):
am = self._makeOne()
config = self._makeConfig()
zopedir = config.zopehome = self._makeTempdir()
self.assertEqual(am.getZOPE_HOME(), zopedir)
def test_getINSTANCE_HOME(self):
am = self._makeOne()
config = self._makeConfig()
......
src/App/tests/test_Extensions.py deleted 100644 → 0
View file @ 31b6b4d9
##############################################################################
#
# Copyright (c) 2010 Zope Foundation and Contributors.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
""" Unit tests for App.Extensions module
"""
import unittest
class FuncCodeTests(unittest.TestCase):
def _getTargetClass(self):
from App.Extensions import FuncCode
return FuncCode
def _makeOne(self, f, im=0):
return self._getTargetClass()(f, im)
def test_ctor_not_method_no_args(self):
def f():
pass
fc = self._makeOne(f)
self.assertEqual(fc.co_varnames, ())
self.assertEqual(fc.co_argcount, 0)
def test_ctor_not_method_w_args(self):
def f(a, b):
pass
fc = self._makeOne(f)
self.assertEqual(fc.co_varnames, ('a', 'b'))
self.assertEqual(fc.co_argcount, 2)
def test_ctor_w_method_no_args(self):
def f(self):
pass
fc = self._makeOne(f, im=1)
self.assertEqual(fc.co_varnames, ())
self.assertEqual(fc.co_argcount, 0)
def test_ctor_w_method_w_args(self):
def f(self, a, b):
pass
fc = self._makeOne(f, im=1)
self.assertEqual(fc.co_varnames, ('a', 'b'))
self.assertEqual(fc.co_argcount, 2)
def test___cmp___None(self):
def f(self):
pass
fc = self._makeOne(f, im=1)
self.assertTrue(cmp(fc, None) > 0)
def test___cmp___non_FuncCode(self):
def f(self):
pass
fc = self._makeOne(f, im=1)
self.assertTrue(cmp(fc, object()) > 0)
def test___cmp___w_FuncCode_same_args(self):
def f(self, a, b):
pass
def g(self, a, b):
pass
fc = self._makeOne(f, im=1)
fc2 = self._makeOne(g, im=1)
self.assertTrue(cmp(fc, fc2) == 0)
def test___cmp___w_FuncCode_different_args(self):
def f(self):
pass
def g(self, a, b):
pass
fc = self._makeOne(f, im=1)
fc2 = self._makeOne(g, im=1)
self.assertTrue(cmp(fc, fc2) < 0)
class _TempdirBase:
_old_Products___path__ = None
_tmpdirs = ()
_old_sys_path = None
_added_path = None
def tearDown(self):
import shutil
if self._old_Products___path__ is not None:
import Products
Products.__path__ = self._old_Products___path__
for tmpdir in self._tmpdirs:
shutil.rmtree(tmpdir)
if self._old_sys_path is not None:
import sys
sys.path[:] = self._old_sys_path
for k, v in sys.modules.items():
if getattr(v, '__file__', '').startswith(self._added_path):
del sys.modules[k]
def _makeTempdir(self):
import tempfile
tmp = tempfile.mkdtemp()
self._tmpdirs += (tmp,)
return tmp
def _makePathDir(self):
import sys
dir = self._makeTempdir()
self._old_sys_path = sys.path[:]
sys.path.insert(0, dir)
self._added_path = dir
return dir
def _makeTempExtension(self, name='foo', extname='Extensions', dir=None):
import os
if dir is None:
dir = self._makeTempdir()
if name is None:
extdir = os.path.join(dir, extname)
else:
extdir = os.path.join(dir, name, extname)
os.makedirs(extdir)
return extdir
def _makeTempProduct(self, name='foo', extname='Extensions'):
import Products
self._old_Products___path__ = Products.__path__[:]
root = self._makeTempdir()
pdir = self._makeTempExtension(name=name, extname=extname, dir=root)
Products.__path__ = (root,)
return pdir
def _makeFile(self, dir, name, text='#extension'):
import os
fqn = os.path.join(dir, name)
f = open(fqn, 'w')
f.write(text)
f.flush()
f.close()
return fqn
class Test_getPath(_TempdirBase, unittest.TestCase):
def _callFUT(self, prefix, name, checkProduct=1, suffixes=('',), cfg=None):
from App.Extensions import getPath
return getPath(prefix, name, checkProduct, suffixes, cfg)
def _makeConfig(self, **kw):
class DummyConfig:
def __init__(self, **kw):
self.__dict__.update(kw)
return DummyConfig(**kw)
def test_name_as_path_raises(self):
self.assertRaises(ValueError, self._callFUT, 'Extensions', 'foo/bar')
def test_found_in_product(self):
instdir = self._makeTempdir()
swdir = self._makeTempdir()
cfg = self._makeConfig(instancehome=instdir,
softwarehome=swdir,
)
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py')
path = self._callFUT('Extensions', 'foo.extension',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, ext)
def test_not_found_in_product(self):
instdir = self._makeTempdir()
swdir = self._makeTempdir()
cfg = self._makeConfig(instancehome=instdir,
softwarehome=swdir,
)
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py')
path = self._callFUT('Extensions', 'foo.other',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, None)
def test_wo_checkProduct_skips_product(self):
import Products
self._old_Products___path__ = Products.__path__
del Products.__path__ # so any iteration will raise
instdir = self._makeTempdir()
instext = self._makeTempExtension(name=None, dir=instdir)
instfqn = self._makeFile(instext, 'extension.py')
swdir = self._makeTempdir()
swext = self._makeTempExtension(name=None, dir=swdir)
swfqn = self._makeFile(swext, 'extension.py')
cfg = self._makeConfig(instancehome=instdir,
softwarehome=swdir,
)
path = self._callFUT('Extensions', 'extension', checkProduct=0,
suffixes=('py',), cfg=cfg)
self.assertEqual(path, instfqn)
def test_w_cfg_extensions(self):
cfgdir = self._makeTempdir()
cfgfqn = self._makeFile(cfgdir, 'extension.py')
instdir = self._makeTempdir()
instext = self._makeTempExtension(name=None, dir=instdir)
instfqn = self._makeFile(instext, 'extension.py')
swdir = self._makeTempdir()
swext = self._makeTempExtension(name=None, dir=swdir)
swfqn = self._makeFile(swext, 'extension.py')
cfg = self._makeConfig(extensions=cfgdir,
instancehome=instdir,
softwarehome=swdir,
)
path = self._callFUT('Extensions', 'extension', checkProduct=0,
suffixes=('py',), cfg=cfg)
self.assertEqual(path, cfgfqn)
def test_not_found_in_instancehome(self):
import os
instdir = self._makeTempdir()
zopedir = self._makeTempdir()
swdir = os.path.join(zopedir, 'src')
os.mkdir(swdir)
zopeext = self._makeTempExtension(name=None, dir=zopedir)
zopefqn = self._makeFile(zopeext, 'extension.py')
cfg = self._makeConfig(instancehome=instdir,
softwarehome=swdir,
)
path = self._callFUT('Extensions', 'extension',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, zopefqn)
def test_no_swhome(self):
instdir = self._makeTempdir()
cfg = self._makeConfig(instancehome=instdir,
)
extdir = self._makeTempProduct()
path = self._callFUT('Extensions', 'extension',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, None)
def test_search_via_import_one_dot(self):
import os
instdir = self._makeTempdir()
cfg = self._makeConfig(instancehome=instdir,
)
pathdir = self._makePathDir()
pkgdir = os.path.join(pathdir, 'somepkg')
os.mkdir(pkgdir)
self._makeFile(pkgdir, '__init__.py', '#package')
pkgext = self._makeTempExtension(name=None, dir=pkgdir)
pkgfqn = self._makeFile(pkgext, 'extension.py')
path = self._callFUT('Extensions', 'somepkg.extension',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, pkgfqn)
def test_search_via_import_multiple_dots(self):
import os
instdir = self._makeTempdir()
cfg = self._makeConfig(instancehome=instdir,
)
pathdir = self._makePathDir()
pkgdir = os.path.join(pathdir, 'somepkg')
os.mkdir(pkgdir)
self._makeFile(pkgdir, '__init__.py', '#package')
subpkgdir = os.path.join(pkgdir, 'subpkg')
os.mkdir(subpkgdir)
self._makeFile(subpkgdir, '__init__.py', '#subpackage')
subpkgext = self._makeTempExtension(name=None, dir=subpkgdir)
subpkgfqn = self._makeFile(subpkgext, 'extension.py')
path = self._callFUT('Extensions', 'somepkg.subpkg.extension',
suffixes=('py',), cfg=cfg)
self.assertEqual(path, subpkgfqn)
"""
Index: lib/python/App/Extensions.py
===================================================================
--- lib/python/App/Extensions.py (revision 28473)
+++ lib/python/App/Extensions.py (working copy)
@@ -87,8 +87,14 @@
r = _getPath(product_dir, os.path.join(p, prefix), n, suffixes)
if r is not None: return r
+
import App.config
cfg = App.config.getConfiguration()
+
+ if (prefix=="Extensions") and (cfg.extensions is not None):
+ r=_getPath(cfg.extensions, '', name, suffixes)
+ if r is not None: return r
+
sw=os.path.dirname(os.path.dirname(cfg.softwarehome))
for home in (cfg.instancehome, sw):
r=_getPath(home, prefix, name, suffixes)
"""
class Test_getObject(_TempdirBase, unittest.TestCase):
def _callFUT(self, module, name, reload=0, modules=None):
from App.Extensions import getObject
if modules is not None:
return getObject(module, name, reload, modules)
return getObject(module, name, reload)
def test_cache_miss(self):
from zExceptions import NotFound
MODULES = {'somemodule': {}}
self.assertRaises(NotFound,
self._callFUT, 'somemodule', 'name', modules=MODULES)
def test_cache_hit(self):
obj = object()
MODULES = {'somemodule': {'name': obj}}
found = self._callFUT('somemodule', 'name', modules=MODULES)
self.assertTrue(found is obj)
def test_no_such_module(self):
from zExceptions import NotFound
MODULES = {}
self.assertRaises(NotFound, self._callFUT,
'nonesuch', 'name', modules=MODULES)
self.assertFalse('nonesuch' in MODULES)
def test_not_found_in_module(self):
from zExceptions import NotFound
MODULES = {}
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py')
self.assertRaises(NotFound, self._callFUT,
'foo.extension', 'name', modules=MODULES)
self.assertTrue('foo.extension' in MODULES)
self.assertFalse('named' in MODULES['foo.extension'])
def test_found_in_module(self):
MODULES = {}
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py', EXTENSION_PY)
found = self._callFUT('foo.extension', 'named', modules=MODULES)
self.assertEqual(found, 'NAMED')
self.assertTrue('foo.extension' in MODULES)
self.assertEqual(MODULES['foo.extension']['named'], 'NAMED')
def test_found_in_module_pyc(self):
from compileall import compile_dir
import os
MODULES = {}
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py', EXTENSION_PY)
compile_dir(extdir, quiet=1)
os.remove(ext)
found = self._callFUT('foo.extension', 'named', modules=MODULES)
self.assertEqual(found, 'NAMED')
self.assertTrue('foo.extension' in MODULES)
self.assertEqual(MODULES['foo.extension']['named'], 'NAMED')
def test_found_in_module_after_cache_miss(self):
cached = {}
MODULES = {'foo.extension': cached}
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py', EXTENSION_PY)
found = self._callFUT('foo.extension', 'named', modules=MODULES)
self.assertEqual(found, 'NAMED')
self.assertEqual(cached['named'], 'NAMED')
def test_found_in_module_after_cache_hit_but_reload(self):
cached = {'named': 'BEFORE'}
MODULES = {'foo.extension': cached}
extdir = self._makeTempProduct()
ext = self._makeFile(extdir, 'extension.py', EXTENSION_PY)
found = self._callFUT('foo.extension', 'named', reload=1,
modules=MODULES)
self.assertEqual(found, 'NAMED')
self.assertEqual(cached['named'], 'NAMED')
class Test_getBrain(_TempdirBase, unittest.TestCase):
def _callFUT(self, module, name, reload=0, modules=None):
from App.Extensions import getBrain
if modules is not None:
return getBrain(module, name, reload, modules)
return getBrain(module, name, reload)
def test_no_module_no_class_yields_NoBrains(self):
from App.Extensions import NoBrains
self.assertTrue(self._callFUT('', '') is NoBrains)
def test_missing_name(self):
from App.Extensions import NoBrains
from zExceptions import NotFound
self.assertTrue(self._callFUT('', '') is NoBrains)
MODULES = {'somemodule': {}}
self.assertRaises(NotFound,
self._callFUT, 'somemodule', 'name', modules=MODULES)
def test_not_a_class(self):
from App.Extensions import NoBrains
self.assertTrue(self._callFUT('', '') is NoBrains)
MODULES = {'somemodule': {'name': object()}}
self.assertRaises(ValueError,
self._callFUT, 'somemodule', 'name', modules=MODULES)
def test_found_class(self):
from App.Extensions import NoBrains
self.assertTrue(self._callFUT('', '') is NoBrains)
MODULES = {'somemodule': {'name': self.__class__}}
self.assertEqual(self._callFUT('somemodule', 'name', modules=MODULES),
self.__class__)
EXTENSION_PY = """\
named = 'NAMED'
"""
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(FuncCodeTests),
unittest.makeSuite(Test_getPath),
unittest.makeSuite(Test_getObject),
unittest.makeSuite(Test_getBrain),
))
src/App/tests/test_setConfiguration.py
View file @ e1276ff7
......@@ -26,15 +26,11 @@ class SetConfigTests(unittest.TestCase):
# Save away everything as we need to restore it later on
self.clienthome = self.getconfig('clienthome')
self.instancehome = self.getconfig('instancehome')
self.softwarehome = self.getconfig('softwarehome')
self.zopehome = self.getconfig('zopehome')
self.debug_mode = self.getconfig('debug_mode')
def tearDown(self):
self.setconfig(clienthome=self.clienthome,
instancehome=self.instancehome,
softwarehome=self.softwarehome,
zopehome=self.zopehome,
debug_mode=self.debug_mode)
def getconfig(self, key):
......@@ -71,28 +67,6 @@ class SetConfigTests(unittest.TestCase):
self.assertEqual(__builtin__.INSTANCE_HOME, 'foo')
self.assertEqual(Globals.INSTANCE_HOME, 'foo')
def testSoftwareHomeLegacySources(self):
import os
import App.FindHomes
import Globals # for data
import __builtin__
self.setconfig(softwarehome='foo')
self.assertEqual(os.environ.get('SOFTWARE_HOME'), 'foo')
self.assertEqual(App.FindHomes.SOFTWARE_HOME, 'foo')
self.assertEqual(__builtin__.SOFTWARE_HOME, 'foo')
self.assertEqual(Globals.SOFTWARE_HOME, 'foo')
def testZopeHomeLegacySources(self):
import os
import App.FindHomes
import Globals # for data
import __builtin__
self.setconfig(zopehome='foo')
self.assertEqual(os.environ.get('ZOPE_HOME'), 'foo')
self.assertEqual(App.FindHomes.ZOPE_HOME, 'foo')
self.assertEqual(__builtin__.ZOPE_HOME, 'foo')
self.assertEqual(Globals.ZOPE_HOME, 'foo')
def testDebugModeLegacySources(self):
import Globals # for data
self.setconfig(debug_mode=True)
......
src/OFS/ObjectManager.py
View file @ e1276ff7
......@@ -639,9 +639,6 @@ class ObjectManager(CopyContainer,
def _getImportPaths(self):
cfg = getConfiguration()
paths = []
zopehome = getattr(cfg, 'zopehome', None)
if zopehome is not None and cfg.zopehome is not None:
paths.append(zopehome)
if not cfg.instancehome in paths:
paths.append(cfg.instancehome)
if not cfg.clienthome in paths:
......
src/Testing/ZopeTestCase/doc/ENVIRONMENT.txt
View file @ e1276ff7
......@@ -2,12 +2,11 @@
ZTC makes the following assumptions about its environment:
a) The 'ZopeTestCase' package is installed in the Zope "trunk" inside the
'Testing' module, which means: SOFTWARE_HOME/Testing/ZopeTestCase.
'Testing' module.
b) A 'Products' directory exists inside SOFTWARE_HOME and INSTANCE_HOME.
b) none
c) The tests (the 'tests' subdirectories) are located either below a
SOFTWARE_HOME or INSTANCE_HOME, typically in Products/MyCoolProduct/tests.
c) none
d) The somewhat weak assumption is that ZTC can walk up the directory tree from
'tests', and find a 'Products' directory. This is how INSTANCE_HOME
......@@ -23,9 +22,8 @@ The non-trivial part is that INSTANCE_HOME has two distinct purposes:
2) INSTANCE_HOME/custom_zodb.py must be used to set up a ZODB.
ZTC attempts to resolve this by detecting an INSTANCE_HOME for 1) but leaving
the actual environment variable untouched so 2) works by still pointing into
SOFTWARE_HOME/Testing.
ZTC attempts to resolve this by detecting an INSTANCE_HOME but leaving
the actual environment variable untouched
As soon as I allow you to set INSTANCE_HOME yourself, I lose the ability to
distinguish whether you mean 1) or 2) or both.
......
src/Testing/ZopeTestCase/doc/TIMELINES.txt
View file @ e1276ff7
......@@ -5,7 +5,6 @@ When the skeleton test is run by typing 'python testSkeleton.py', it
1. includes file framework.py
1.1 locates and imports the Testing package by means of
- SOFTWARE_HOME environment variable
- auto-detection
1.2 locates and includes file ztc_common.py
......
src/Zope2/Startup/datatypes.py
View file @ e1276ff7
......@@ -115,16 +115,11 @@ class zdaemonEnvironDict(UserDict):
return self.data
# Datatype for the root configuration object
# (adds the softwarehome and zopehome fields; default values for some
# computed paths, configures the dbtab)
# (default values for some computed paths, configures the dbtab)
def root_config(section):
from ZConfig import ConfigurationError
from ZConfig.matcher import SectionValue
here = os.path.dirname(os.path.abspath(__file__))
swhome = os.path.dirname(os.path.dirname(here))
section.softwarehome = swhome
section.zopehome = os.path.dirname(os.path.dirname(swhome))
if section.environment is None:
section.environment = zdaemonEnvironDict()
if section.cgi_environment is None:
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7