def testZopeRunConfigure(self): old_config = getConfiguration() try: os.mkdir(TEMPNAME) os.mkdir(TEMPPRODUCTS) except OSError as why: if why == errno.EEXIST: # already exists pass old_argv = sys.argv sys.argv = [sys.argv[0]] try: fname = os.path.join(TEMPNAME, 'zope.conf') from ZServer.Zope2.Startup.run import configure f = open(fname, 'w') f.write('instancehome %s\nzserver-threads 100\n' % TEMPNAME) f.flush() f.close() configure(fname) new_config = getConfiguration() self.assertEqual(new_config.zserver_threads, 100) finally: sys.argv = old_argv try: os.unlink(fname) except Exception: pass setConfiguration(old_config)
def setUp(self): from Products.CMFCore.DirectoryView import _dirreg WritableFSDVTest.setUp(self) self._registerDirectory(self) info = _dirreg.getDirectoryInfo(self.ob.fake_skin._dirpath) self.use_dir_mtime = info.use_dir_mtime self.saved_cfg_debug_mode = getConfiguration().debug_mode getConfiguration().debug_mode = True
def setUpZope(self, app, configurationContext): # Load ZCML for this package import collective.anonfeedback xmlconfig.file('configure.zcml', collective.anonfeedback, context=configurationContext) # Temporary vardir self.vardir = tempfile.mkdtemp() self.oldclienthome = config.getConfiguration().clienthome config.getConfiguration().clienthome = os.path.join(self.vardir, 'instance')
def install_deferred(): # Temporarily patch fiveconfigure with findProducts able to see only # products under reload paths and execute Five configuration directives import sauna.reload import Products.Five.fiveconfigure setattr(Products.Five.fiveconfigure, "findProducts", findDeferredProducts) load_config("fiveconfigure.zcml", sauna.reload) setattr(Products.Five.fiveconfigure, "findProducts", findProducts) # Five pushes old-style product initializations into # Products._packages_to_initialize-list. We must loop through that list # for our reloaded packages and try to install them. import Products from App.config import getConfiguration from OFS.Application import install_package from Zope2.App.startup import app # FIXME: Is this really the only way to get our app-object? app = app() # XXX: Help! Should we use use app._p_jar-stuff around here? debug_mode = getConfiguration().debug_mode from sauna.reload import reload_paths for module, init_func in getattr(Products, "_packages_to_initialize", []): if getattr(module, "__file__") in reload_paths: install_package(app, module, init_func, raise_exc=debug_mode) if hasattr(Products, "_packages_to_initialize"): del Products._packages_to_initialize
def _getCache(): config = getConfiguration() servers = config.product_config['flashuploader'].get('memcache-address') servers = servers.split(',') servers = [x.strip() for x in servers] client = memcache.Client(servers) return client
def init_config(self): config = getConfiguration() if not hasattr(config, 'product_config'): config.product_config = {} config.product_config['expired-users'] = self.expired_users_config() setConfiguration(config)
def coreVersions(self): # Useful core information. vars = {} get_dist = pkg_resources.get_distribution vars['Zope'] = get_dist('Zope').version vars['Python'] = sys.version vars['Platform'] = sys.platform vars['Plone'] = get_dist('Products.CMFPlone').version vars['Plone Instance'] = self.getInstanceVersion() vars['Plone File System'] = self.getFileSystemVersion() vars['CMF'] = get_dist('Products.CMFCore').version vars['Debug mode'] = getConfiguration().debug_mode and 'Yes' or 'No' try: vars['PIL'] = get_dist('PIL').version except pkg_resources.DistributionNotFound: try: vars['PIL'] = get_dist('PILwoTK').version except pkg_resources.DistributionNotFound: try: vars['PIL'] = "%s (Pillow)" % get_dist('Pillow').version except pkg_resources.DistributionNotFound: try: import _imaging _imaging # pyflakes vars['PIL'] = 'unknown' except ImportError: pass return vars
def __init__(self, event): config = getConfiguration() config.servers zserver = [ server for server in config.servers if isinstance(server, zhttp_server) ][0] time.sleep(5) warmup_bin = os.environ.get('WARMUP_BIN', False) warmup_ini = os.environ.get('WARMUP_INI', False) if not warmup_bin: logger.error('WARMUP_BIN not set') if not warmup_ini: logger.error('WARMUP_INI not set') if warmup_bin and warmup_ini: logger.info('Executing intances warmup') proc = subprocess.Popen( [ "%s %s -p %d" % ( warmup_bin, warmup_ini, zserver.port ) ], shell=True )
def _cook_check(self): if self._v_last_read and not getConfiguration().debug_mode: return __traceback_info__ = self.filename try: mtime = os.path.getmtime(self.filename) except OSError: mtime = 0 if self._v_program is not None and mtime == self._v_last_read: return f = open(self.filename, "rb") try: text = f.read(XML_PREFIX_MAX_LENGTH) except: f.close() raise t = sniff_type(text) if t != "text/xml": # For HTML, we really want the file read in text mode: f.close() f = open(self.filename, 'U') text = '' text += f.read() f.close() self.pt_edit(text, t) self._cook() if self._v_errors: LOG.error('Error in template %s' % '\n'.join(self._v_errors)) return self._v_last_read = mtime
def __init__(self, name, storage=None, **kw): ZopeDatabase.__init__(self, SectionValue({"container_class": None, "mount_points": []}, name, None)) if storage is not None: self.open = lambda database_name, databases: ZODB.DB( storage, database_name=database_name, databases=databases, **kw ) getConfiguration().dbtab.db_factories[name] = self
def is_enabled(): try: from App.config import getConfiguration debug_mode = getConfiguration().debug_mode except Exception: debug_mode = False return debug_mode
def version_list(self): # Return a list of currently installed products/versions path_join=os.path.join isdir=os.path.isdir exists=os.path.exists cfg = getConfiguration() product_dir=path_join(cfg.softwarehome,'Products') product_names=os.listdir(product_dir) product_names.sort() info=[] for product_name in product_names: package_dir=path_join(product_dir, product_name) if not isdir(package_dir): continue version_txt = None for name in ('VERSION.TXT', 'VERSION.txt', 'version.txt'): v = path_join(package_dir, name) if 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 test_getBookmarkableURLs(self): saved_state = getattr(getConfiguration(), 'zmi_bookmarkable_urls', True) om = self._makeOne() # Configuration flag OFF getConfiguration().zmi_bookmarkable_urls = False self.assertFalse(om.getBookmarkableURLs()) # Configuration flag ON getConfiguration().zmi_bookmarkable_urls = True self.assertTrue(om.getBookmarkableURLs()) # Cleanup getConfiguration().zmi_bookmarkable_urls = saved_state
def setUp(self): global original_config if original_config is None: original_config = getConfiguration() self.schema = getSchema() os.makedirs(TEMPNAME) os.makedirs(TEMPPRODUCTS)
def is_enabled(): try: from App.config import getConfiguration debug_mode = getConfiguration().debug_mode except: debug_mode = False if debug_mode: return True try: from zope import testrunner from zope.testrunner import options except ImportError: from zope.testing import testrunner from zope.testing.testrunner import options frame = sys._getframe(2) while frame is not None and frame.f_code is not testrunner.run.func_code: frame = frame.f_back if frame is not None: try: pm = options.get_options().post_mortem return bool(pm) except: # options not recognized by test runnergiven pass return False
def setUp(self): import collective.taskqueue xmlconfig.file('configure.zcml', collective.taskqueue, context=self['configurationContext']) # Configure config = getConfiguration() config.product_config = {'collective.taskqueue': {'queue': self.queue}} taskqueue.reset() # Define logging request handler to replace ZPublisher def logging_handler(app, request, response): logger.info(request.getURL() + request.get("PATH_INFO")) response.stdout.write('HTTP/1.1 204\r\n') response.stdout.close() # Define ZPublisher-based request handler to be used with zserver def zserver_handler(app, request, response): from ZPublisher import publish_module publish_module(app, request=request, response=response) # Create TaskQueueServer from collective.taskqueue.server import TaskQueueServer if not self.zserver_enabled: self['server'] = TaskQueueServer(queue=self.queue, handler=logging_handler) else: self['server'] = TaskQueueServer(queue=self.queue, handler=zserver_handler, concurrent_limit=0)
def install_products(app): # Install a list of products into the basic folder class, so # that all folders know about top-level objects, aka products folder_permissions = get_folder_permissions() meta_types=[] done={} debug_mode = getConfiguration().debug_mode transaction.get().note('Prior to product installs') transaction.commit() products = get_products() for priority, product_name, index, product_dir in products: # For each product, we will import it and try to call the # intialize() method in the product __init__ module. If # the method doesnt exist, we put the old-style information # together and do a default initialization. if done.has_key(product_name): continue done[product_name]=1 install_product(app, product_dir, product_name, meta_types, folder_permissions, raise_exc=debug_mode) # Delayed install of packages-as-products for module, init_func in tuple(get_packages_to_initialize()): install_package(app, module, init_func, raise_exc=debug_mode) Products.meta_types=Products.meta_types+tuple(meta_types) InitializeClass(Folder.Folder)
def get_view(name=None, context=None, request=None): """Get a BrowserView object. :param name: [required] Name of the view. :type name: string :param context: [required] Context on which to get view. :type context: context object :param request: [required] Request on which to get view. :type request: request object :raises: :class:`~plone.api.exc.MissingParameterError`, :class:`~plone.api.exc.InvalidParameterError` :Example: :ref:`content_get_view_example` """ # It happens sometimes that ACTUAL_URL is not set in tests. To be nice # and not throw strange errors, we set it to be the same as URL. # TODO: if/when we have api.env.test_mode() boolean in the future, use that config = getConfiguration() if config.dbtab.__module__ == "plone.testing.z2": request["ACTUAL_URL"] = request["URL"] try: return getMultiAdapter((context, request), name=name) except: # get a list of all views so we can display their names in the error # msg sm = getSiteManager() views = sm.adapters.lookupAll(required=(providedBy(context), providedBy(request)), provided=Interface) views_names = [view[0] for view in views] raise InvalidParameterError( "Cannot find a view with name '{0}'.\n" "Available views are:\n" "{1}".format(name, "\n".join(sorted(views_names))) )
def main(argv=sys.argv): if len(sys.argv) < 3: raise Exception("must specify a zope config file and a celery command") argv = argv filepath = sys.argv[2] os.environ['ZOPE_CONFIG'] = filepath sys.argv = [''] from Zope2.Startup.run import configure configure(os.environ['ZOPE_CONFIG']) # Fix for setuptools generated scripts, so that it will # work with multiprocessing fork emulation. # (see multiprocessing.forking.get_preparation_data()) if __name__ != "__main__": sys.modules["__main__"] = sys.modules[__name__] # load tasks up tasks = dict([(i.name, i.load()) for i in iter_entry_points( group='celery_tasks', name=None)]) tasks = getConfiguration().environment.get('CELERY_TASKS') if tasks: try: __import__(tasks) except ImportError: logger.warn('error importing tasks: ' + tasks) argv.remove(argv[2]) # restore argv sys.argv = argv Worker(app=getCelery()).execute_from_commandline()
def _tailFile(self, file_name, line_number=10): """ Do a 'tail -f -n line_number filename' """ log_file = os.path.join(getConfiguration().instancehome, file_name) if not os.path.exists(log_file): raise IOError, 'The file: %s does not exist.' % log_file char_per_line = 75 with open(log_file,'r') as tailed_file: while 1: try: tailed_file.seek(-1 * char_per_line * line_number, 2) except IOError: tailed_file.seek(0) pos = tailed_file.tell() lines = tailed_file.read().split("\n") if len(lines) > (line_number + 1) or not pos: break # The lines are bigger than we thought char_per_line *= 1.3 # Inc for retry start = max(len(lines) - line_number - 1, 0) return "\n".join(lines[start:len(lines)])
def get_zope_config(): '''Try and figure out where the groupserver config is, using Zope :returns: The location of the config file from Zope. :rtype: str :raises gs.config.errors.ConfigFileError: The configration file failed to be read. The location of the configration file should either be the ``$ZOPE_HOME/etc/gsconfig.ini`` or ``$INSTANCE_HOME/etc/gsconfig.ini``, with the latter preferred for backwards compatibility, but the former being more typical. This normally equates to ``etc/gsconfig.ini`` within what the installation documentation refers to as *the GroupServer directory*. ''' cfg = getConfiguration() # The old location. May go AWOL. iConfigPath = path_join(cfg.instancehome, 'etc/gsconfig.ini') # The better location. zConfigPath = path_join(cfg.zopehome, 'etc/gsconfig.ini') if ((not isfile(iConfigPath)) and (not isfile(zConfigPath))): m = 'Could not read the configuration, as neither "{0}" nor '\ '"{1}" exist.' msg = m.format(iConfigPath, zConfigPath) raise ConfigFileError(msg) retval = iConfigPath if isfile(iConfigPath) else zConfigPath return retval
def __init__(self, **kwargs): self.redis = redis.StrictRedis(**kwargs) self.pubsub = self.redis.pubsub() # Create pubsub for notifications self._requeued_processing = False # Requeue old processing on start if getattr(getConfiguration(), 'debug_mode', False): self.redis.ping() # Ensure Zope startup to crash when Redis down
def getDatabaseNames(self, quote=False): configuration = getConfiguration() names = configuration.dbtab.listDatabaseNames() names.sort() if quote: return [(name, parse.quote(name)) for name in names] return names
def prepare(self): self.setupInitialLogging() self.setupLocale() self.setupSecurityOptions() self.setupPublisher() # Start ZServer servers before we drop privileges so we can bind to # "low" ports: self.setupZServer() self.setupServers() # drop privileges after setting up servers self.dropPrivileges() self.setupFinalLogging() self.makeLockFile() self.makePidFile() self.setupInterpreter() self.startZope() self.serverListen() from App.config import getConfiguration config = getConfiguration() self.registerSignals() # emit a "ready" message in order to prevent the kinds of emails # to the Zope maillist in which people claim that Zope has "frozen" # after it has emitted ZServer messages. logger.info('Ready to handle requests') self.sendEvents()
def cacheKey(func, rules_url, theme_node): if getConfiguration().debug_mode: raise DontCache() key = md5() key.update(rules_url) key.update(html.tostring(theme_node)) return key.hexdigest()
def readZopeConf(): """Overriding default values with the ones from zope.conf """ global SITE_CHARSET, DOWNLOAD_BUFFER_SIZE if SITE_CHARSET is not None: # We run this only once return default_pdfbook_config = { 'site-charset': 'utf-8', 'download-buffer-size': '40000' } from App.config import getConfiguration try: pdfbook_config = getConfiguration().product_config[PROJECTNAME.lower()] except (KeyError, AttributeError): # Zope 2.10 raises a KeyError when Zope 2.12 raises an AttributeError # if the <product-config ...> is missing in zope.conf pdfbook_config = default_pdfbook_config getConfData = lambda key: pdfbook_config.get(key, default_pdfbook_config[key]) SITE_CHARSET = getConfData('site-charset') DOWNLOAD_BUFFER_SIZE = int(getConfData('download-buffer-size')) return
def getContentUri(self, context): #1. determine subject uri for context # FIXME: use property, attribute, context absolute url from Products.ZCatalog.interfaces import ICatalogBrain if ICatalogBrain.providedBy(context): uuid = context.UID else: context = aq_base(context) uuid = IUUID(context, None) if uuid is None: # we probably deal with a new contet object that does not have an # uuid yet let's generate one from plone.uuid.interfaces import IMutableUUID, IUUIDGenerator generator = queryUtility(IUUIDGenerator) if generator is None: return # TODO: raise error uuid = generator() if not uuid: return # TODO: raise error IMutableUUID(context).set(uuid) #url = base_uri + /@@redirect-to-uuid/<uuid> #uri = context.subjecturi # FIXME: shouldn't consult config here, IORDF does this. try: settings = getConfiguration().product_config.get('gu.plone.rdf', dict()) baseuri = settings['baseuri'] except Exception as e: # FIXME: be specific about exceptions baseuri = 'urn:plone:' LOG.warn("No baseuri configured: using %s (%s)", baseuri, e) contenturi = "%s%s" % (baseuri, uuid) return contenturi
def base_dir(self): """ Return the beginning of the source file path determined by the path_origin (including a trailing path seperator). If path_origin is 'root' it returns '', because the file_path is supposed to be absolute. If the file_path() is absolute already it will return '', too. """ if os.path.isabs(self.file_path()): return "" elif self.path_origin() == "root": return os.path.sep elif self.path_origin() == "module": tpl = os.path.split(self.module().__file__) module_path = tpl[0] return module_path + os.path.sep elif self.path_origin() == "instance": cfg = getConfiguration() if cfg.instancehome[-1] == os.path.sep: return cfg.instancehome else: return cfg.instancehome + os.path.sep
def getInstanceMetadata(self): """ return instance metadata""" pm = getattr(self.context, 'portal_migration') result = {} versions = {} versions = pm.coreVersions() result['python_version'] = versions['Python'] result['zope_version'] = versions['Zope'] result['plone_version'] = versions['Plone'] if versions['Debug mode'] == 'Yes': result['debug_mode'] = True else: result['debug_mode'] = False result['instance_home'] = getConfiguration().instancehome result['http_port'] = self.getPort() result['uptime'] = self.process_time(_when=None) result['etasp_version'] = self.getETASPVersion() result_json = json.dumps(result) response = self.request.RESPONSE setheader = response.setHeader setheader('Content-Length', 1) setheader('Content-Type', 'application/json; charset=utf-8') return result_json
def __getitem__(self, name): configuration = getConfiguration() db = configuration.dbtab.getDatabase(name=name) m = AltDatabaseManager() m.id = name m._p_jar = FakeConnection(db, self.getPhysicalRoot()._p_jar) return m.__of__(self)
def run(self): # the mainloop. try: from App.config import getConfiguration config = getConfiguration() # NOQA import Lifetime Lifetime.loop() from ZServer.Zope2.Startup.config import ZSERVER_EXIT_CODE sys.exit(ZSERVER_EXIT_CODE) finally: self.shutdown()
def resetCredentials(self, request, response): """ resetCredential by expiring auth cookie """ config = getConfiguration() cookie_domain = self._get_cookie_domain(config) if cookie_domain: response.expireCookie(self.cookie_name, path=self.path, domain=cookie_domain) else: response.expireCookie(self.cookie_name, path=self.path)
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: paths.append(cfg.clienthome) return paths
def set_db_config(host=None, port=None): # Modify the database configuration manually from App.config import getConfiguration for serverConfig in getConfiguration().databases: adapterConfig= serverConfig.config.storage.config.adapter.config xhost, xport = adapterConfig.host, adapterConfig.port if host: xhost = host if port: xport = port adapterConfig.host, adapterConfig.port = xhost, xport
def run(self): # the mainloop. try: from App.config import getConfiguration config = getConfiguration() import ZServer import Lifetime Lifetime.loop() sys.exit(ZServer.exit_code) finally: self.shutdown()
def _default_encoding(): ''' Retrieve default encoding from config ''' global _DEFAULT_ENCODING if _DEFAULT_ENCODING is None: from App.config import getConfiguration config = getConfiguration() try: _DEFAULT_ENCODING = config.zpublisher_default_encoding except AttributeError: _DEFAULT_ENCODING = 'utf8' return _DEFAULT_ENCODING
def start_successlogging(unused): """start successlogging if configured.""" from App.config import getConfiguration config = getConfiguration().product_config.get('successlogging') if config is None: return # not configured global _log_good, _log_bad _log_good = Rotator(config['filebase'] + '_good', lock=True) _log_bad = Rotator(config['filebase'] + '_bad', lock=True) # register publication observers provideHandler(handle_request_success) provideHandler(handle_request_failure)
def readZopeConf(): """Read custom config from zope.conf or use defaults """ global SITE_CHARSET, BATCH_SIZE from App.config import getConfiguration import codecs default_config = {'charset': 'UTF-8', 'batch-size': 30} try: pg_config = getConfiguration().product_config['ploneglossary'] except KeyError, e: pg_config = default_config
def _default_encoding(): '''get default encoding from configuration if zpublisher_default_encoding is not set, use utf8 ''' # avoid doing this at module scope! from App.config import getConfiguration global _DEFAULT_ENCODING if _DEFAULT_ENCODING is None: config = getConfiguration() _DEFAULT_ENCODING = getattr(config, 'zpublisher_default_encoding', 'utf8')
def logConflicts(self, v, REQUEST): self.conflict_errors += 1 level = getattr(getConfiguration(), 'conflict_error_log_level', 0) if not self.conflict_logger.isEnabledFor(level): return False self.conflict_logger.log( level, "%s at %s: %s (%d conflicts (%d unresolved) " "since startup at %s)", v.__class__.__name__, REQUEST.get('PATH_INFO', '<unknown>'), v, self.conflict_errors, self.unresolved_conflict_errors, startup_time) return True
def develop_theme(self): ''' Check if the theme should be recompiled every time the transform is applied ''' if not getConfiguration().debug_mode: return False if self.debug_theme(): return True if environ.get('DIAZO_ALWAYS_CACHE_RULES'): return False return True
def start_monitor(unused): """start the request monitor if configured.""" from App.config import getConfiguration config = getConfiguration().product_config.get('requestmonitor') if config is None: return # not configured # register publication observers provideHandler(handle_request_start) provideHandler(handle_request_end) monitor = _Monitor(config) start_new_thread(monitor.run, ())
def setUpZope(self, app, configurationContext): cfg = getConfiguration() cfg.product_config = {'beaker': self.zconfigData} import cs.auth.googleplus xmlconfig.file('configure.zcml', cs.auth.googleplus, context=configurationContext) import cs.auth.googleplus.tests xmlconfig.file('tests.zcml', cs.auth.googleplus.tests, context=configurationContext)
def initialize(): try: from raven.contrib.zope import ZopeSentryHandler except ImportError: return else: from App.config import getConfiguration env = getattr(getConfiguration(), 'environment', {}) sentry_dsn = env.get('SENTRY_DSN') if sentry_dsn: sentry_handler = ZopeSentryHandler(sentry_dsn) publish_error_log.addHandler(sentry_handler)
def getRedirectFromConfiguration(): config = getConfiguration() if not hasattr(config, 'product_config'): return False product_config = config.product_config if config is None: return False configuration = product_config.get('collective.redirectacquired', None) if configuration is not None: return configuration.get('redirect', 'False') == 'True' else: return False
def _installBusinessTemplateList( self, bt_list, update_repository_bt_list=True, *args, **kwargs): """ Before installing BTs by calling the original method: 1/ Get filesystem BT repositories and set them to Template Tool 2/ Update BT repositories 3/ Resolve dependencies: * dependency_list: recursive. * test_dependency_list: non-recursive. 4/ Install BTs as before """ template_tool = self.portal.portal_templates from Products.ERP5.ERP5Site import getBootstrapDirectory bt5_path_list = [ os.environ.get('erp5_tests_bootstrap_path') or getBootstrapDirectory() ] bt5_path = os.environ.get('erp5_tests_bt5_path') if bt5_path: bt5_path_list.extend([ bt5_path.replace('*', '') for bt5_path in bt5_path.split(',') ]) else: from App.config import getConfiguration instancehome = getConfiguration().instancehome bt5_path_list.append(os.path.join(instancehome, 'bt5')) bt5_path_list = [ bt5_path for bt5_path in bt5_path_list if os.path.exists(bt5_path) ] template_tool.updateRepositoryBusinessTemplateList( bt5_path_list) url_bt_tuple_list = [ ('%s/%s' % (repository, bt_title), bt_title) for repository, bt_title in template_tool.resolveBusinessTemplateListDependency( bt_list, with_test_dependency_list=True) ] return super(_ZodbTestComponentBootstrapOnly, self)._installBusinessTemplateList( url_bt_tuple_list, *args, **kwargs)
def prepareReportDirectory(self, expected_filename): """ Remove existing report with the given filename if any. This must be called before a report button is clicked """ filename_path = os.path.join(getConfiguration().instancehome, 'var', expected_filename) if os.path.exists(filename_path): os.remove(filename_path) return 'Done'
def structured_text(v, name='(Unknown name)', md={}): if isinstance(v, str): txt = v elif aq_base(v).meta_type in ['DTML Document', 'DTML Method']: txt = aq_base(v).read_raw() else: txt = str(v) level = getConfiguration().structured_text_header_level doc = DocumentWithImages()(txt) return HTML()(doc, level, header=False)
def PropertiedUser__init__(self, id, login=None): orig_PropertiedUser__init__(self, id, login) if id in getattr( getattr( getConfiguration(), 'product_config', {}, ).get('erp5'), 'developer_list', (), ): self._roles[DEVELOPER_ROLE_ID] = 1
def start_timelogging(unused): """start timelogging if configured.""" from App.config import getConfiguration config = getConfiguration().product_config.get('timelogging') if config is None: return # not configured global _logfile _logfile = Rotator(config['filebase'], lock=True) # indicate restart _log('0', info='restarted') # register publication observers provideHandler(handle_request_start) provideHandler(handle_request_success) provideHandler(handle_request_failure)
def get_token(self): configuration = getConfiguration() conf = configuration.product_config.get('collective.converse') otp_service = pyotp.TOTP(conf.get('otp_seed'), digits=collective.converse.OTP_DIGITS, interval=collective.converse.OTP_INTERVAL) otp = otp_service.generate_otp(otp_service.timecode(datetime.utcnow())) nonce = ''.join([str(random.randint(0, 9)) for i in range(32)]) string_to_sign = otp + nonce + self.jid signature = hmac.new(conf.get('token_secret'), string_to_sign, hashlib.sha256).digest() return u"{} {}".format(otp + nonce, base64.b64encode(signature))
def setUp(self): from Products.CMFCore.DirectoryView import _dirreg WritableFSDVTest.setUp(self) self.saved_cfg_debug_mode = getConfiguration().debug_mode getConfiguration().debug_mode = True # initialise skins self._registerDirectory(self) # add a method to the fake skin folder self._writeFile('test2.py', "return 'test2'") # edit the test1 method self._writeFile('test1.py', "return 'new test1'") # add a new folder mkdir(join(self.skin_path_name, 'test3')) info = _dirreg.getDirectoryInfo(self.ob.fake_skin._dirpath) info.reload() self.use_dir_mtime = info.use_dir_mtime
def _get_handlebars_template_cache_key(method, path): """Calculate cache key for get_handlebars_template for a specific template. In development, the template is cached until the template file is modified. In production, the template is cached for the process duration. Especially while deploying (updating), it is important that a production process does not reload components from the file system in order to keep code and resources in sync. """ if not getConfiguration().debug_mode: return str(path) else: return '{0!s}-{0.mtime}'.format(Path(path))
def _getZopeConfigurationFile(relative_path="", mode="r"): """ Get a configuration file from the instance using relative path """ if ".." in relative_path or relative_path.startswith("/"): raise Unauthorized("In Relative Path, you cannot use .. or startwith / for security reason.") instance_home = getConfiguration().instancehome file_path = os.path.join(instance_home, relative_path) if not os.path.exists(file_path): raise IOError, 'The file: %s does not exist.' % file_path return open(file_path, mode)
def _setCookie(self, cookie, response): cookie = binascii.b2a_base64(cookie).rstrip() # disable secure cookie in development mode, to ease local testing if getConfiguration().debug_mode: secure = False else: secure = self.secure options = dict(path=self.path, secure=secure, http_only=True) if self.cookie_domain: options['domain'] = self.cookie_domain if self.cookie_lifetime: options['expires'] = cookie_expiration_date(self.cookie_lifetime) response.setCookie(self.cookie_name, cookie, **options)
def _updateFromFS(self): parsed = self._parsed if not parsed or getConfiguration().debug_mode: try: mtime = os.stat(self._filepath).st_mtime except: mtime = 0.0 if not parsed or mtime != self._file_mod_time: self._readFile(1) if mtime != self._file_mod_time or mtime == 0.0: self.ZCacheable_invalidate() self._file_mod_time = mtime self._parsed = 1
def setUpZCML(self): super(MuninZopeFixture, self).setUpZCML() from zope.configuration import xmlconfig import munin.zope cfg = getConfiguration() cfg.product_config = {'munin.zope': {'secret': 'muninsecret'}} # load zcml & install package context = self['configurationContext'] fiveconfigure.debug_mode = True xmlconfig.file('configure.zcml', munin.zope, context=context) # load our holder_view for the 'threads.txt' test xmlconfig.file('tests.zcml', munin.zope, context=context) fiveconfigure.debug_mode = False
def _listFilesystemObjects(self): """ Return a mapping of any filesystem objects we "hold". """ if (self._v_filesystem_objects is not None and not getConfiguration().debug_mode): return self._v_filesystem_objects if not self.filesystem_path: return {'testcases': (), 'subdirs': {}} path = os.path.abspath(self.filesystem_path) self._v_filesystem_objects = self._grubFilesystem(path) return self._v_filesystem_objects
def makePidFile(self): options = getConfiguration() try: IO_ERRORS = (IOError, OSError, WindowsError) except NameError: IO_ERRORS = (IOError, OSError) try: if os.path.exists(options.pid_filename): os.unlink(options.pid_filename) with open(options.pid_filename, 'w') as fp: fp.write(str(os.getpid())) except IO_ERRORS: pass
def __init__(self, name, storage=None, **kw): ZopeDatabase.__init__( self, SectionValue({ 'container_class': None, 'mount_points': [], }, name, None)) if storage is not None: self.open = lambda database_name, databases: ZODB.DB( storage, database_name=database_name, databases=databases, **kw) getConfiguration().dbtab.db_factories[name] = self