def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os from djblets.util.misc import generate_cache_serials from djblets import log from reviewboard import signals # Set up logging. log.init_logging() logging.info("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate cache serials generate_cache_serials() signals.initializing.send(sender=None)
def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os from django.conf import settings from djblets.util.misc import generate_cache_serials from djblets import log from reviewboard import signals # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags # Set up logging. log.init_logging() if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate cache serials generate_cache_serials() signals.initializing.send(sender=None)
def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os from djblets.util.misc import generate_cache_serials from djblets import log from reviewboard import signals # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags # Set up logging. log.init_logging() logging.info("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate cache serials generate_cache_serials() signals.initializing.send(sender=None)
def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os import settings_local # Set RBSITE_PYTHON_PATH to the path we need for any RB-bundled # scripts we may call. os.environ['RBSITE_PYTHONPATH'] = \ os.path.dirname(settings_local.__file__) from django.conf import settings from django.db import DatabaseError from djblets import log from djblets.cache.serials import generate_ajax_serial from reviewboard import signals from reviewboard.admin.siteconfig import load_site_config from reviewboard.extensions.base import get_extension_manager # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags is_running_test = getattr(settings, 'RUNNING_TEST', False) if not is_running_test: # Set up logging. log.init_logging() load_site_config() if not is_running_test: if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate the AJAX serial, used for AJAX request caching. generate_ajax_serial() # Load all extensions try: get_extension_manager().load() except DatabaseError: # This database is from a time before extensions, so don't attempt # to load any extensions yet. pass signals.initializing.send(sender=None)
def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os import sys import settings_local # Set PYTHONPATH to match the directory of settings, for subprocesses. os.environ['PYTHONPATH'] = '%s:%s' % \ (os.path.dirname(settings_local.__file__), os.environ.get('PYTHONPATH', '')) from django.conf import settings from django.db import DatabaseError from djblets.util.misc import generate_ajax_serial from djblets import log from reviewboard import signals from reviewboard.extensions.base import get_extension_manager # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags # Set up logging. log.init_logging() if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate the AJAX serial, used for AJAX request caching. generate_ajax_serial() # Load all extensions try: get_extension_manager().load() except DatabaseError: # This database is from a time before extensions, so don't attempt to # load any extensions yet. pass signals.initializing.send(sender=None)
def process_view(self, request, callback, callback_args, callback_kwargs): """ Handler for processing a view. This will run the profiler on the view if profiling is allowed in the settings and the user specified the profiling parameter on the URL. """ init_logging() if ('profiling' in request.GET and getattr(settings, "LOGGING_ALLOW_PROFILING", False)): import cProfile self.profiler = cProfile.Profile() args = (request,) + callback_args settings.DEBUG = True return self.profiler.runcall(callback, *args, **callback_kwargs)
def initialize(): """Begins initialization of Review Board. This sets up the logging, generates cache serial numbers, and then fires an initializing signal that other parts of the codebase can connect to. This must be called for such features as e-mail notification to work. """ import logging import os from django.conf import settings from django.db import DatabaseError from djblets.util.misc import generate_ajax_serial from djblets import log from reviewboard import signals from reviewboard.extensions.base import get_extension_manager # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags # Set up logging. log.init_logging() if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate the AJAX serial, used for AJAX request caching. generate_ajax_serial() # Load all extensions try: get_extension_manager().load() except DatabaseError: # This database is from a time before extensions, so don't attempt to # load any extensions yet. pass signals.initializing.send(sender=None)
def initialize(): """Begin initialization of Review Board. This sets up the logging, generates cache serial numbers, loads extensions, and sets up other aspects of Review Board. Once it has finished, it will fire the :py:data:`reviewboard.signals.initializing` signal. This must be called at some point before most features will work, but it will be called automatically in a standard install. If you are writing an extension or management command, you do not need to call this yourself. """ import logging import os import settings_local # Set RBSITE_PYTHON_PATH to the path we need for any RB-bundled # scripts we may call. os.environ[b'RBSITE_PYTHONPATH'] = \ os.path.dirname(settings_local.__file__) from Crypto import Random from django.conf import settings from django.db import DatabaseError from djblets import log from djblets.cache.serials import generate_ajax_serial from reviewboard import signals from reviewboard.admin.siteconfig import load_site_config from reviewboard.extensions.base import get_extension_manager # This overrides a default django templatetag (url), and we want to make # sure it will always get loaded in every python instance. import reviewboard.site.templatetags is_running_test = getattr(settings, 'RUNNING_TEST', False) if not is_running_test: # Force PyCrypto to re-initialize the random number generator. Random.atfork() # Set up logging. log.init_logging() load_site_config() if not is_running_test: if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate the AJAX serial, used for AJAX request caching. generate_ajax_serial() # Store the AJAX serial as a template serial, so we have a reference # to the real serial last modified timestamp of our templates. This # is useful since the extension manager will be modifying AJAX_SERIAL # to prevent stale caches for templates using hooks. Not all templates # use hooks, and may want to base cache keys off TEMPLATE_SERIAL # instead. # # We only want to do this once, so we don't end up replacing it # later with a modified AJAX_SERIAL later. if not getattr(settings, 'TEMPLATE_SERIAL', None): settings.TEMPLATE_SERIAL = settings.AJAX_SERIAL try: # Django >= 1.7 from django import setup setup() except ImportError: # Django < 1.7 pass if not is_running_test: # Load all extensions try: get_extension_manager().load() except DatabaseError: # This database is from a time before extensions, so don't attempt # to load any extensions yet. pass signals.initializing.send(sender=None)
def initialize(load_extensions=True, setup_logging=True, setup_templates=True): """Begin initialization of Review Board. This sets up the logging, generates cache serial numbers, loads extensions, and sets up other aspects of Review Board. Once it has finished, it will fire the :py:data:`reviewboard.signals.initializing` signal. This must be called at some point before most features will work, but it will be called automatically in a standard install. If you are writing an extension or management command, you do not need to call this yourself. Args: load_extensions (bool, optional): Whether extensions should be automatically loaded upon initialization. If set, extensions will only load if the site has been upgraded to the latest version of Review Board. setup_logging (bool, optional): Whether to set up logging based on the configured settings. This can be disabled if the caller has their own logging configuration. setup_templates (bool, optional): Whether to set up state for template rendering. This can be disabled if the caller has no need for template rendering of any kind. This does not prevent template rendering from happening, but may change the output of some templates. Keep in mind that many pieces of functionality, such as avatars and some management commands, may be impacted by this setting. """ import importlib import logging import os os.environ.setdefault(str('DJANGO_SETTINGS_MODULE'), str('reviewboard.settings')) import settings_local # Set RBSITE_PYTHON_PATH to the path we need for any RB-bundled # scripts we may call. os.environ[str('RBSITE_PYTHONPATH')] = \ os.path.dirname(settings_local.__file__) from django import setup from django.apps import apps if not apps.ready: setup() from django.conf import settings from django.db import DatabaseError from djblets import log from djblets.cache.serials import generate_ajax_serial from djblets.siteconfig.models import SiteConfiguration from reviewboard import signals from reviewboard.admin.siteconfig import load_site_config from reviewboard.extensions.base import get_extension_manager is_running_test = getattr(settings, 'RUNNING_TEST', False) if setup_logging and not is_running_test: # Set up logging. log.init_logging() load_site_config() if (setup_templates or load_extensions) and not is_running_test: if settings.DEBUG: logging.debug("Log file for Review Board v%s (PID %s)" % (get_version_string(), os.getpid())) # Generate the AJAX serial, used for AJAX request caching. generate_ajax_serial() # Store the AJAX serial as a template serial, so we have a reference # to the real serial last modified timestamp of our templates. This # is useful since the extension manager will be modifying AJAX_SERIAL # to prevent stale caches for templates using hooks. Not all templates # use hooks, and may want to base cache keys off TEMPLATE_SERIAL # instead. # # We only want to do this once, so we don't end up replacing it # later with a modified AJAX_SERIAL later. if not getattr(settings, 'TEMPLATE_SERIAL', None): settings.TEMPLATE_SERIAL = settings.AJAX_SERIAL siteconfig = SiteConfiguration.objects.get_current() if load_extensions and not is_running_test: installed_version = get_version_string() if siteconfig.version == installed_version: # Load all extensions try: get_extension_manager().load() except DatabaseError: # This database is from a time before extensions, so don't # attempt to load any extensions yet. pass else: logging.warning( 'Extensions will not be loaded. The site must ' 'be upgraded from Review Board %s to %s.', siteconfig.version, installed_version) signals.initializing.send(sender=None)