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 report(request,
           template_name='reviews/dashboard.html'):
    report_name = request.GET.get('name', None)
    if not report_name:
        raise Http404

    # Check if its a configured report in admin pages
    from reviewboard.extensions.base import get_extension_manager
    from rbcustomreports.extension import CustomReportsExtension

    extension_manager = get_extension_manager()
    extension = extension_manager.get_enabled_extension(
        CustomReportsExtension.id)
    if report_name not in extension.settings['selected_reports']:
        raise Http404

    report_title = reports[report_name]['title']
    if not report_title:
        raise Http404

    extra_context = {}
    rb_object = request.GET.get('object', None)
    if rb_object:
        extra_context['rb_object'] = rb_object

    grid = reports[report_name]['data_class'](request, title=report_title,
                                              extra_context=extra_context)
    return grid.render_to_response(template_name, extra_context={
        'sidebar_hooks': DashboardHook.hooks,
    })

    def create(self, request, review_request_id, *args, **kwargs):
        try:
            review_request = review_request_resource.get_object(
                request, *args, review_request_id=review_request_id, **kwargs)
        except ObjectDoesNotExist:
            return DOES_NOT_EXIST

        em = get_extension_manager()
        ext = em.get_enabled_extension('buildbotstatus.extension.Buildbotstatus')
        url = ext.settings['buildbot_url']
        if not url:
            raise Exception('No Buildbot URL configured')
        commit_id = review_request.commit_id
        statuses = find_builds(url, commit_id)

        for status in statuses:
            status['url'] = 'http://%s/builders/%s/builds/%s' % \
                    (url, status['builderName'], status['number'])
            status['cssClass'] = 'buildbot-failure'
            status['result'] = ' '.join(status['text'])
            warnings = int(status.get('warnings-count', 0))
            if warnings > 0:
                status['cssClass'] = 'buildbot-warning'
                status['result'] = '%s warnings' % warnings
            elif 'success' in status['result']:
                status['cssClass'] = 'buildbot-success'

        return 201, {
            self.item_result_key: json.dumps(statuses),
        }

def include_enabled_extensions(settings):
    """
    This adds enabled extensions to the INSTALLED_APPS cache
    so that operations like syncdb and evolve will take extensions
    into consideration.
    """
    # Some of our checks require access to django.conf.settings, so
    # tell Django about our settings.
    #
    # This must go before the imports.
    setup_environ(settings)

    from django.db.models.loading import load_app
    from django.db import DatabaseError

    from reviewboard.extensions.base import get_extension_manager

    try:
        manager = get_extension_manager()
        manager.load()
    except DatabaseError:
        # This database is from a time before extensions, so don't attempt to
        # load any extensions yet.
        return

    for extension in manager.get_enabled_extensions():
        load_app(extension.info.app_name)

def broadcast_message(context):
    from rbbroadcastmessage.extension import BroadcastMessageExtension
    extension_manager = get_extension_manager()
    extension = extension_manager.get_enabled_extension(
        BroadcastMessageExtension.id)
    if extension.settings.has_key('broadcast_message'):
        return extension.settings['broadcast_message']
    else:
        return ""

    def refresh_tools_view(self, request, template_name="refresh.html"):
        extension_manager = get_extension_manager()
        extension = extension_manager.get_enabled_extension(
            ReviewBotExtension.id)

        ReviewBotTool.objects.all().update(in_last_update=False)
        extension.send_refresh_tools()

        return render_to_response(
            template_name,
            RequestContext(request, {},  current_app=self.admin_site.name))

    def get_extension_manager(self):
        """Return the extension manager used for these extensions.

        Subclasses don't need to override this unless they're doing something
        highly specialized.

        Returns:
            djblets.extensions.manager.ExtensionManager:
            The extension manager used for the unit tests.
        """
        return get_extension_manager()

    def create(self, request, *args, **kwargs):
        ext = get_extension_manager().get_enabled_extension("mozreview.extension.MozReviewExtension")

        testing = ext.get_settings("autoland_testing", False)

        if not testing and not request.user.has_perm("mozreview.add_autolandeventlogentry"):
            return PERMISSION_DENIED

        try:
            fields = json.loads(request.body)

            for field_name in self.fields:
                assert type(fields[field_name]) == self.fields[field_name]["type"]
        except (ValueError, IndexError, KeyError, AssertionError) as e:
            return INVALID_FORM_DATA, {"error": "%s" % e}
        try:
            autoland_request = AutolandRequest.objects.get(pk=fields["request_id"])
        except AutolandRequest.DoesNotExist:
            return DOES_NOT_EXIST

        rr = ReviewRequest.objects.get(pk=autoland_request.review_request_id)

        if fields["landed"]:
            autoland_request.repository_revision = fields["result"]
            autoland_request.save()

            # If we've landed to the "inbound" repository, we'll close the
            # review request automatically.
            landing_repo = rr.repository.extra_data.get("landing_repository_url")
            if autoland_request.repository_url == landing_repo:
                rr.close(ReviewRequest.SUBMITTED)

            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields["request_id"], status=AutolandEventLogEntry.SERVED, details=fields["result"]
            )

        elif not fields.get("error_msg") and fields.get("result"):
            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields["request_id"],
                status=AutolandEventLogEntry.REQUESTED,
                details=fields["result"],
            )
        else:
            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields["request_id"],
                status=AutolandEventLogEntry.PROBLEM,
                error_msg=fields["error_msg"],
            )

        lock_id = get_autoland_lock_id(rr.id, autoland_request.repository_url, autoland_request.push_revision)
        release_lock(lock_id)

        return 200, {}

    def create(self, request, *args, **kwargs):
        ext = get_extension_manager().get_enabled_extension(
            'mozreview.extension.MozReviewExtension')

        testing = ext.settings.get('autoland_testing', False)

        if not testing and not request.user.has_perm(
                'mozreview.add_autolandeventlogentry'):
            return PERMISSION_DENIED

        try:
            fields = json.loads(request.body)
            landed = fields['landed']
            for field_name in fields:
                assert type(fields[field_name]) == self.fields[field_name]['type']
        except (ValueError, IndexError, AssertionError) as e:
            return INVALID_FORM_DATA, {
                'error': e,
                }

        try:
            ImportPullRequestRequest.objects.get(pk=fields['request_id'])
        except ImportPullRequestRequest.DoesNotExist:
            return DOES_NOT_EXIST

        if landed:
            # Autoland gives us a review request url, we need to extract the id
            try:
                review_request_id = int(fields['result'].split('/')[-1])
            except ValueError as e:
                return INVALID_FORM_DATA, {'error': e}

            ImportPullRequestRequest.objects.filter(
                pk=fields['request_id']).update(
                review_request_id=review_request_id, bugid=fields['bugid'])

            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields['request_id'],
                status=AutolandEventLogEntry.SERVED,
                details=fields['result'])
        else:
            # We need to store the bugid even if the import failed so we can
            # use that same bug for later imports of this pullrequest.
            ImportPullRequestRequest.objects.filter(
                pk=fields['request_id']).update(bugid=fields['bugid'])

            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields['request_id'],
                status=AutolandEventLogEntry.PROBLEM,
                error_msg=fields['error_msg']
            )

        return 200, {}

    def create(self, request, *args, **kwargs):
        ext = get_extension_manager().get_enabled_extension(
            'mozreview.extension.MozReviewExtension')

        testing = ext.settings.get('autoland_testing', False)

        if not testing and not request.user.has_perm(
                'mozreview.add_autolandeventlogentry'):
            return PERMISSION_DENIED

        try:
            fields = json.loads(request.body)
            landed = fields['landed']
            # result and error_msg are mutually exclusive
            filtered_field = 'error_msg' if landed else 'result'
            mandatory_fields = [f for f in self.fields if f != filtered_field]
            for field_name in mandatory_fields:
                assert type(fields[field_name]) == self.fields[field_name]['type']
        except (ValueError, IndexError, AssertionError) as e:
            return INVALID_FORM_DATA, {
                'error': e,
                }
        try:
            AutolandRequest.objects.get(pk=fields['request_id'])
        except AutolandRequest.DoesNotExist:
            return DOES_NOT_EXIST

        if landed:
            autoland_request = AutolandRequest.objects.filter(pk=fields['request_id'])
            autoland_request.update(repository_revision=fields['result'])

            assert len(autoland_request) == 1

            # If we've landed to the "inbound" repository, we'll close the
            # review request automatically.
            rr = ReviewRequest.objects.get(pk=autoland_request[0].review_request_id)
            landing_repo = rr.repository.extra_data.get('landing_repository_url')
            if autoland_request[0].repository_url == landing_repo:
                rr.close(ReviewRequest.SUBMITTED)

            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields['request_id'],
                status=AutolandEventLogEntry.SERVED,
                details=fields['result'])

        else:
            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields['request_id'],
                status=AutolandEventLogEntry.PROBLEM,
                error_msg=fields['error_msg']
            )

        return 200, {}

    def handle(self, *args, **options):
        if len(args) != 1:
            raise CommandError(
                _('You must specify an extension ID to disable.'))

        extension_id = args[0]
        extension_mgr = get_extension_manager()

        try:
            extension_mgr.disable_extension(extension_id)
        except Exception as e:
            raise CommandError(_('Unexpected error disabling extension: %s')
                               % e)

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
    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 cache serials
    generate_cache_serials()

    # Load all extensions
    get_extension_manager().load()

    signals.initializing.send(sender=None)

def import_pullrequest(request, user, repo, pullrequest):
    ext = get_extension_manager().get_enabled_extension(
        'mozreview.extension.MozReviewExtension')
    enabled = ext.get_settings('autoland_import_pullrequest_ui_enabled', False)

    if not enabled:
        return HttpResponseForbidden('Importing pullrequests is disabled')

    trigger_url = import_pullrequest_trigger_resource.get_uri(request)

    template = get_template('mozreview/import-pullrequest.html')
    return HttpResponse(template.render(Context({
        'request': request,
        'user': user,
        'repo': repo,
        'pullrequest': pullrequest,
        'trigger_url': trigger_url,
    })))

    def handle(self, *args, **options):
        if len(args) != 1:
            raise CommandError(
                _('You must specify an extension ID to enable.'))

        extension_id = args[0]
        extension_mgr = get_extension_manager()

        try:
            extension_mgr.enable_extension(extension_id)
        except InvalidExtensionError:
            raise CommandError(_('%s is not a valid extension ID.')
                               % extension_id)
        except EnablingExtensionError as e:
            raise CommandError(_('Error enabling extension: %s\n\n%s')
                               % (e.message, e.load_error))
        except Exception as e:
            raise CommandError(_('Unexpected error enabling extension: %s')
                               % e)

def include_enabled_extensions(settings):
    """
    This adds enabled extensions to the INSTALLED_APPS cache
    so that operations like syncdb and evolve will take extensions
    into consideration.
    """
    from django.db.models.loading import load_app
    from django.db import DatabaseError

    from reviewboard.extensions.base import get_extension_manager

    try:
        manager = get_extension_manager()
    except DatabaseError:
        # This database is from a time before extensions, so don't attempt to
        # load any extensions yet.
        return

    for extension in manager.get_enabled_extensions():
        load_app(extension.info.app_name)

def get_ldap_connection():
    """Return an ldap connection.

    `None` will be returned if a connection cannot be made for
    any reason.
    """
    ext = get_extension_manager().get_enabled_extension("mozreview.extension.MozReviewExtension")
    url = ext.settings.get("ldap_url")
    user = ext.settings.get("ldap_user")
    password = ext.settings.get("ldap_password")

    if any([not url, not user, not password]):
        logging.error("MozReview ldap support configured incorrectly.")
        return None

    try:
        c = ldap.initialize(url)
        c.simple_bind_s(user, password)
    except ldap.LDAPError as e:
        logging.error("Failed to connect to ldap: %s" % e)
        return None

    return c

    def create(self, request, *args, **kwargs):
        ext = get_extension_manager().get_enabled_extension("mozreview.extension.MozReviewExtension")

        testing = ext.settings.get("autoland_testing", False)

        if not testing and not request.user.has_perm("mozreview.add_autolandeventlogentry"):
            return PERMISSION_DENIED

        try:
            fields = json.loads(request.body)
            landed = fields["landed"]
            # result and error_msg are mutually exclusive
            filtered_field = "error_msg" if landed else "result"
            mandatory_fields = [f for f in self.fields if f != filtered_field]
            for field_name in mandatory_fields:
                assert type(fields[field_name]) == self.fields[field_name]["type"]
        except (ValueError, IndexError, AssertionError) as e:
            return INVALID_FORM_DATA, {"error": e}
        try:
            AutolandRequest.objects.get(pk=fields["request_id"])
        except AutolandRequest.DoesNotExist:
            return DOES_NOT_EXIST

        if landed:
            AutolandRequest.objects.filter(pk=fields["request_id"]).update(repository_revision=fields["result"])

            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields["request_id"], status=AutolandEventLogEntry.SERVED, details=fields["result"]
            )
        else:
            AutolandEventLogEntry.objects.create(
                autoland_request_id=fields["request_id"],
                status=AutolandEventLogEntry.PROBLEM,
                error_msg=fields["error_msg"],
            )

        return 200, {}

    def __init__(self):
        self.extension = ExtensionResource(get_extension_manager())

        self._loaded = False

from django.conf import settings
from django.conf.urls.defaults import patterns, include, url
from django.contrib import admin

from reviewboard import initialize
from reviewboard.extensions.base import get_extension_manager
from reviewboard.webapi.resources import root_resource


extension_manager = get_extension_manager()


handler404 = 'django.views.defaults.page_not_found'
handler500 = 'django.views.defaults.server_error'


# Load in all the models for the admin UI.
if not admin.site._registry:
    admin.autodiscover()


# URLs global to all modes
urlpatterns = patterns('',
    (r'^admin/extensions/', include('djblets.extensions.urls'),
     {'extension_manager': extension_manager}),
    (r'^admin/', include('reviewboard.admin.urls')),
)

# Add static media if running in DEBUG mode
if settings.DEBUG or getattr(settings, 'RUNNING_TEST', False):
    urlpatterns += patterns('django.views.static',