500 error on displayable_links.js in django, mezzanine, nginx

Question

I am getting a 500 error on displayable_links.js. I assume it is something with my ssl setup. Using Django 1.9.1, Python 2.7.5, PostgreSQL 9.2.14, and Mezzanine 4.1. Happens in debug and behind gunicorn. I have * for allowed hosts just to eliminate that as a possibility. It also happens directly over port 8000.

My nginc.conf:

 worker_processes  1;
error_log  /var/log/nginx/error.log;
error_log   /var/log/nginx/error.log  notice;
error_log   /var/log/nginx/error.log  info;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

server {
    listen       80  default_server;
    root  /opt/www/;
    return 301 https://www2.example.com$request_uri;
    gzip on;
gzip_disable "msie6";
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
}
server {
    listen       443 ssl;
    server_name  www2.example.com;
    add_header X-Frame-Options SAMEORIGIN;
    server_name_in_redirect off;
     root  /opt/www/;
    gzip off;
gzip_disable "msie6";
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_buffers 16 8k;
gzip_http_version 1.1;
gzip_types text/plain
               text/css
               application/json
               application/javascript
               application/x-javascript
               text/xml
               application/xml
               application/xml+rss
               text/javascript;
    ssl_certificate      /etc/httpd/conf.d/2016.example.com.crt;
    ssl_certificate_key  /etc/httpd/conf.d/2016.example.com.key;
    ssl_trusted_certificate /etc/httpd/conf.d/intermediate.crt;
    ssl_dhparam /etc/httpd/conf.d/dhparams.pem;
    add_header Strict-Transport-Security max-age=31536000;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_buffer_size 8k;
    ssl_session_cache shared:SSL:30m;
    ssl_session_timeout 30m;
    ssl_stapling on;
    resolver 8.8.8.8;
    ssl_stapling_verify on;

    ssl_prefer_server_ciphers  on;
    proxy_redirect off;
    location / {
         proxy_pass http://127.0.0.1:8000;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
    location /static/ {
         autoindex on;
         root /opt/www/;
    }
}

}

And my settings.py:

from __future__ import absolute_import, unicode_literals
enter code here`enter code here`import os
    from django.utils.translation import ugettext_lazy as _
    SEARCH_MODEL_CHOICES = []
    PAGE_MENU_TEMPLATES = (
         (1, _("Top navigation bar"), "pages/menus/dropdown.html"),
         (2, _("Left-hand tree"), "pages/menus/tree.html"),
         (3, _("Footer"), "pages/menus/footer.html"),
    )
    PAGE_MENU_TEMPLATES_DEFAULT = (2,)
    USE_MODELTRANSLATION = False
    ALLOWED_HOSTS = ['*']
    SERVER_EMAIL = 'server@example.com'
    ADMINS = [('example', 'example@example.com'),]
    TIME_ZONE = 'UTC'
    USE_TZ = True
    LANGUAGE_CODE = "en"
    LANGUAGES = (
        ('en', _('English')),
    )
    SITE_TITLE = "example Systems"
    DEBUG = False
    SESSION_EXPIRE_AT_BROWSER_CLOSE = True
    SITE_ID = 1
    USE_I18N = False
    AUTHENTICATION_BACKENDS = ("mezzanine.core.auth_backends.MezzanineBackend",)
    FILE_UPLOAD_PERMISSIONS = 0o644
    DATABASES = {
        "default": {
            "ENGINE": "django.db.backends.postgresql",
            "NAME": "example",
            "USER": "example",
            "PASSWORD": "example",
            "HOST": "127.0.0.1",
            "PORT": "5432",
        }
    }
    PROJECT_APP_PATH = os.path.dirname(os.path.abspath(__file__))
    PROJECT_APP = os.path.basename(PROJECT_APP_PATH)
    PROJECT_ROOT = BASE_DIR = os.path.dirname(PROJECT_APP_PATH)
    CACHE_MIDDLEWARE_KEY_PREFIX = PROJECT_APP
    STATIC_URL = "https://www2.example.com/static/"
    STATIC_ROOT = "/opt/www/static/"

    MEDIA_URL = STATIC_URL + "media/"
    MEDIA_ROOT = os.path.join(PROJECT_ROOT, *MEDIA_URL.strip("/").split("/"))
    ROOT_URLCONF = "%s.urls" % PROJECT_APP
    TEMPLATES = [{u'APP_DIRS': True,
                  u'BACKEND': u'django.template.backends.django.DjangoTemplates',
                  u'DIRS': (u'/opt/www/modernbiz/theme/templates', u'/opt/www/templates'),
                  u'OPTIONS': {u'builtins': [u'mezzanine.template.loader_tags'],
                               u'context_processors': (u'django.contrib.auth.context_processors.auth',
                                                       u'django.contrib.messages.context_processors.messages',
                                                       u'django.core.context_processors.debug',
                                                       u'django.core.context_processors.i18n',
                                                       u'django.core.context_processors.static',
                                                       u'django.core.context_processors.media',
                                                       u'django.core.context_processors.request',
                                                       u'django.core.context_processors.tz',
                                                       u'mezzanine.conf.context_processors.settings',
                                                       u'mezzanine.pages.context_processors.page')}}]
    INSTALLED_APPS = (
        "modernbiz",
        "django.contrib.admin",
        "django.contrib.auth",
        "django.contrib.contenttypes",
        "django.contrib.redirects",
        "django.contrib.sessions",
        "django.contrib.sites",
        "django.contrib.sitemaps",
        "django.contrib.staticfiles",
        "mezzanine.boot",
        "mezzanine.conf",
        "mezzanine.core",
        "mezzanine.generic",
        "mezzanine.pages",
        "mezzanine.blog",
        "mezzanine.forms",
        "mezzanine.galleries",
        "mezzanine.twitter",
        "howtos",
        "mezzanine.accounts",
        "mezzanine.mobile",
        "polls",
    )
    MIDDLEWARE_CLASSES = (
        "django.middleware.gzip.GZipMiddleware",
        'htmlmin.middleware.MarkRequestMiddleware',
        "mezzanine.core.middleware.UpdateCacheMiddleware",
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
        "mezzanine.core.request.CurrentRequestMiddleware",
        "mezzanine.core.middleware.RedirectFallbackMiddleware",
        "mezzanine.core.middleware.TemplateForDeviceMiddleware",
        "mezzanine.core.middleware.TemplateForHostMiddleware",
        "mezzanine.core.middleware.AdminLoginInterfaceSelectorMiddleware",
        "mezzanine.core.middleware.SitePermissionMiddleware",
        "mezzanine.pages.middleware.PageMiddleware",
        "mezzanine.core.middleware.FetchFromCacheMiddleware",
    )
    PACKAGE_NAME_FILEBROWSER = "filebrowser_safe"
    PACKAGE_NAME_GRAPPELLI = "grappelli_safe"
    OPTIONAL_APPS = (
        "debug_toolbar",
        "django_extensions",
        "compressor",
        PACKAGE_NAME_FILEBROWSER,
        PACKAGE_NAME_GRAPPELLI,
    )
    f = os.path.join(PROJECT_APP_PATH, "local_settings.py")
    if os.path.exists(f):
        exec(open(f, "rb").read())
    try:
        from mezzanine.utils.conf import set_dynamic_settings
    except ImportError:
        pass
    else:
        set_dynamic_settings(globals())
    SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')
    COMPRESS_ENABLED = True
    COMPRESS_OFFLINE = True
    LOGGING = {
        'version': 1,
        'disable_existing_loggers': True,
        'formatters': {
            'verbose': {
                'format': '%(asctime)s %(levelname)s [%(name)s:%(lineno)s] %(module)s %(process)d %(thread)d %(message)s'
            }
        },
        'handlers': {
            'file': {
                'level': 'DEBUG',
                'class': 'logging.FileHandler',
                'formatter': 'verbose',
                'filename': '/var/log/gunicorn/gunicorn.errors',
            }
        },
        'loggers': {
            'django.errors': {
                'level': 'DEBUG',
                'handlers': ['file'],
                'propagate': True,
            },
        }
    }

Edited to add the stacktrace:

Internal Server Error: /displayable_links.js
Traceback (most recent call last):
  File "/usr/lib/python2.7/site-packages/django/core/handlers/base.py", line 149, in get_response
    response = self.process_exception_by_middleware(e, request)
  File "/usr/lib/python2.7/site-packages/django/core/handlers/base.py", line 147, in get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "/usr/lib64/python2.7/site-packages/mezzanine/core/views.py", line 192, in displayable_links_js
    for url, obj in Displayable.objects.url_map(for_user=request.user).items():
  File "/usr/lib64/python2.7/site-packages/mezzanine/core/managers.py", line 366, in url_map
    home = self.model(title=_("Home"))
  File "/usr/lib/python2.7/site-packages/django/db/models/base.py", line 408, in __init__
    val = field.get_default()
  File "/usr/lib/python2.7/site-packages/django/db/models/fields/related.py", line 902, in get_default
    if isinstance(field_default, self.remote_field.model):
TypeError: isinstance() arg 2 must be a class, type, or tuple of classes and types
[01/Feb/2016 20:50:25] "GET /displayable_links.js HTTP/1.0" 500 6309

Answer 1

It has been fixed a few days ago after the 4.1 release. So you need to use the master branch for now until 4.1.1 or 4.2.

https://github.com/stephenmcd/mezzanine/pull/1516

Answer 2

I just resolved this issue with a little hack. All you need is to override the handler of URL endpoint: "^displayable_links.js$" inside your app's urls.py file. Here is what I did:

Create a custom views.py to store your custom handler function:

from django.http import (HttpResponse)
from json import  dumps

def editor_link_handler(request):
    links = []
    sorted_links = sorted(links, key=lambda link: (link[0], link[1]['value']))
    return HttpResponse(dumps([link[1] for link in sorted_links]))

Then, inside your own app's urls.py file. Here is an example code snippet which works for me now:

# urls.py // Skip to the "Important" section for my custom code
from __future__ import unicode_literals

from django.conf.urls import include, url
from django.conf.urls.i18n import i18n_patterns
from django.contrib import admin
from django.views.i18n import set_language

import mezzanine
from mezzanine.core.views import direct_to_template
from mezzanine.conf import settings
from mezzanine.blog.views import blog_post_list

############################
### Important #########
##### Here is my cusom view function to handle the request
##############
from views import editor_link_handler

urlpatterns = i18n_patterns(
    # Change the admin prefix here to use an alternate URL for the
    # admin interface, which would be marginally more secure.
    url("^admin/", include(admin.site.urls)),
)
##################
###Important:#######
##### Here comes the serious stuff (my custom code)
###############

urlpatterns += [
    url("^displayable_links.js$", editor_link_handler,
        name="editor_link_handler"),
]

Remember this url rule needs to be anywhere BEFORE you do:

url("^", include("mezzanine.urls")),

Because in Django URL dispatchers, ordering does matter!

If you did this as instructed, when you click the "add link" button in TinyMCE, it will be handled by your custom handler, and you should be able to add links to your blog/page without a problem.

---

NOTE:

• This is nothing more than a hack, please comment below if this doesn't work for you or that you have a better solution.