changeset 0:b79a1205e2c6

Init mezzanine project
author Jordi <jordigh@stickjan.com>
date Sun, 18 May 2014 23:53:12 +0000
parents
children 5fa205356c5c
files .gitignore .hgignore __init__.py deploy/crontab deploy/gunicorn.conf.py.template deploy/local_settings.py.template deploy/nginx.conf deploy/supervisor.conf fabfile.py manage.py requirements.txt settings.py urls.py wsgi.py
diffstat 14 files changed, 1163 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
new file mode 100644
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+*.pyc
+*.pyo
+*.db
+.DS_Store
+.coverage
+local_settings.py
+/static
new file mode 100644
--- /dev/null
+++ b/.hgignore
@@ -0,0 +1,10 @@
+syntax: glob
+*.pyc
+*.pyo
+*.db
+.DS_Store
+.coverage
+local_settings.py
+
+syntax: regexp
+^static/
new file mode 100644
new file mode 100644
--- /dev/null
+++ b/deploy/crontab
@@ -0,0 +1,1 @@
+*/5 * * * * %(user)s %(manage)s poll_twitter
new file mode 100644
--- /dev/null
+++ b/deploy/gunicorn.conf.py.template
@@ -0,0 +1,7 @@
+from __future__ import unicode_literals
+import multiprocessing
+
+bind = "127.0.0.1:%(gunicorn_port)s"
+workers = multiprocessing.cpu_count() * 2 + 1
+loglevel = "error"
+proc_name = "%(proj_name)s"
new file mode 100644
--- /dev/null
+++ b/deploy/local_settings.py.template
@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+SECRET_KEY = "%(secret_key)s"
+NEVERCACHE_KEY = "%(nevercache_key)s"
+ALLOWED_HOSTS = [%(domains_python)s]
+
+DATABASES = {
+    "default": {
+        # Ends with "postgresql_psycopg2", "mysql", "sqlite3" or "oracle".
+        "ENGINE": "django.db.backends.postgresql_psycopg2",
+        # DB name or path to database file if using sqlite3.
+        "NAME": "%(proj_name)s",
+        # Not used with sqlite3.
+        "USER": "%(proj_name)s",
+        # Not used with sqlite3.
+        "PASSWORD": "%(db_pass)s",
+        # Set to empty string for localhost. Not used with sqlite3.
+        "HOST": "127.0.0.1",
+        # Set to empty string for default. Not used with sqlite3.
+        "PORT": "",
+    }
+}
+
+SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTOCOL", "https")
+
+CACHE_MIDDLEWARE_SECONDS = 60
+
+CACHE_MIDDLEWARE_KEY_PREFIX = "%(proj_name)s"
+
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.memcached.MemcachedCache",
+        "LOCATION": "127.0.0.1:11211",
+    }
+}
+
+SESSION_ENGINE = "django.contrib.sessions.backends.cache"
new file mode 100644
--- /dev/null
+++ b/deploy/nginx.conf
@@ -0,0 +1,48 @@
+
+upstream %(proj_name)s {
+    server 127.0.0.1:%(gunicorn_port)s;
+}
+
+server {
+
+    listen 80;
+    %(ssl_disabled)s listen 443 ssl;
+    server_name %(domains_nginx)s;
+    client_max_body_size 10M;
+    keepalive_timeout    15;
+
+    %(ssl_disabled)s ssl_certificate      conf/%(proj_name)s.crt;
+    %(ssl_disabled)s ssl_certificate_key  conf/%(proj_name)s.key;
+    %(ssl_disabled)s ssl_session_cache    shared:SSL:10m;
+    %(ssl_disabled)s ssl_session_timeout  10m;
+    %(ssl_disabled)s ssl_ciphers RC4:HIGH:!aNULL:!MD5;
+    %(ssl_disabled)s ssl_prefer_server_ciphers on;
+
+    location / {
+        proxy_redirect      off;
+        proxy_set_header    Host                    $host;
+        proxy_set_header    X-Real-IP               $remote_addr;
+        proxy_set_header    X-Forwarded-For         $proxy_add_x_forwarded_for;
+        proxy_set_header    X-Forwarded-Protocol    $scheme;
+        proxy_pass          http://%(proj_name)s;
+    }
+
+    location /static/ {
+        root            %(proj_path)s;
+        access_log      off;
+        log_not_found   off;
+    }
+
+    location /robots.txt {
+        root            %(proj_path)s/static;
+        access_log      off;
+        log_not_found   off;
+    }
+
+    location /favicon.ico {
+        root            %(proj_path)s/static/img;
+        access_log      off;
+        log_not_found   off;
+    }
+
+}
new file mode 100644
--- /dev/null
+++ b/deploy/supervisor.conf
@@ -0,0 +1,11 @@
+[group:%(proj_name)s]
+programs=gunicorn_%(proj_name)s
+
+[program:gunicorn_%(proj_name)s]
+command=%(venv_path)s/bin/gunicorn_django -c gunicorn.conf.py -p gunicorn.pid
+directory=%(proj_path)s
+user=%(user)s
+autostart=true
+autorestart=true
+redirect_stderr=true
+environment=LANG="%(locale)s",LC_ALL="%(locale)s",LC_LANG="%(locale)s"
new file mode 100644
--- /dev/null
+++ b/fabfile.py
@@ -0,0 +1,543 @@
+from __future__ import print_function, unicode_literals
+from future.builtins import input, open
+
+import os
+import re
+import sys
+from functools import wraps
+from getpass import getpass, getuser
+from glob import glob
+from contextlib import contextmanager
+from posixpath import join
+
+from fabric.api import env, cd, prefix, sudo as _sudo, run as _run, hide, task
+from fabric.contrib.files import exists, upload_template
+from fabric.colors import yellow, green, blue, red
+
+
+################
+# Config setup #
+################
+
+conf = {}
+if sys.argv[0].split(os.sep)[-1] in ("fab", "fab-script.py"):
+    # Ensure we import settings from the current dir
+    try:
+        conf = __import__("settings", globals(), locals(), [], 0).FABRIC
+        try:
+            conf["HOSTS"][0]
+        except (KeyError, ValueError):
+            raise ImportError
+    except (ImportError, AttributeError):
+        print("Aborting, no hosts defined.")
+        exit()
+
+env.db_pass = conf.get("DB_PASS", None)
+env.admin_pass = conf.get("ADMIN_PASS", None)
+env.user = conf.get("SSH_USER", getuser())
+env.password = conf.get("SSH_PASS", None)
+env.key_filename = conf.get("SSH_KEY_PATH", None)
+env.hosts = conf.get("HOSTS", [""])
+
+env.proj_name = conf.get("PROJECT_NAME", os.getcwd().split(os.sep)[-1])
+env.venv_home = conf.get("VIRTUALENV_HOME", "/home/%s" % env.user)
+env.venv_path = "%s/%s" % (env.venv_home, env.proj_name)
+env.proj_dirname = "project"
+env.proj_path = "%s/%s" % (env.venv_path, env.proj_dirname)
+env.manage = "%s/bin/python %s/project/manage.py" % ((env.venv_path,) * 2)
+env.domains = conf.get("DOMAINS", [conf.get("LIVE_HOSTNAME", env.hosts[0])])
+env.domains_nginx = " ".join(env.domains)
+env.domains_python = ", ".join(["'%s'" % s for s in env.domains])
+env.ssl_disabled = "#" if len(env.domains) > 1 else ""
+env.repo_url = conf.get("REPO_URL", "")
+env.git = env.repo_url.startswith("git") or env.repo_url.endswith(".git")
+env.reqs_path = conf.get("REQUIREMENTS_PATH", None)
+env.gunicorn_port = conf.get("GUNICORN_PORT", 8000)
+env.locale = conf.get("LOCALE", "en_US.UTF-8")
+
+env.secret_key = conf.get("SECRET_KEY", "")
+env.nevercache_key = conf.get("NEVERCACHE_KEY", "")
+
+
+##################
+# Template setup #
+##################
+
+# Each template gets uploaded at deploy time, only if their
+# contents has changed, in which case, the reload command is
+# also run.
+
+templates = {
+    "nginx": {
+        "local_path": "deploy/nginx.conf",
+        "remote_path": "/etc/nginx/sites-enabled/%(proj_name)s.conf",
+        "reload_command": "service nginx restart",
+    },
+    "supervisor": {
+        "local_path": "deploy/supervisor.conf",
+        "remote_path": "/etc/supervisor/conf.d/%(proj_name)s.conf",
+        "reload_command": "supervisorctl reload",
+    },
+    "cron": {
+        "local_path": "deploy/crontab",
+        "remote_path": "/etc/cron.d/%(proj_name)s",
+        "owner": "root",
+        "mode": "600",
+    },
+    "gunicorn": {
+        "local_path": "deploy/gunicorn.conf.py.template",
+        "remote_path": "%(proj_path)s/gunicorn.conf.py",
+    },
+    "settings": {
+        "local_path": "deploy/local_settings.py.template",
+        "remote_path": "%(proj_path)s/local_settings.py",
+    },
+}
+
+
+######################################
+# Context for virtualenv and project #
+######################################
+
+@contextmanager
+def virtualenv():
+    """
+    Runs commands within the project's virtualenv.
+    """
+    with cd(env.venv_path):
+        with prefix("source %s/bin/activate" % env.venv_path):
+            yield
+
+
+@contextmanager
+def project():
+    """
+    Runs commands within the project's directory.
+    """
+    with virtualenv():
+        with cd(env.proj_dirname):
+            yield
+
+
+@contextmanager
+def update_changed_requirements():
+    """
+    Checks for changes in the requirements file across an update,
+    and gets new requirements if changes have occurred.
+    """
+    reqs_path = join(env.proj_path, env.reqs_path)
+    get_reqs = lambda: run("cat %s" % reqs_path, show=False)
+    old_reqs = get_reqs() if env.reqs_path else ""
+    yield
+    if old_reqs:
+        new_reqs = get_reqs()
+        if old_reqs == new_reqs:
+            # Unpinned requirements should always be checked.
+            for req in new_reqs.split("\n"):
+                if req.startswith("-e"):
+                    if "@" not in req:
+                        # Editable requirement without pinned commit.
+                        break
+                elif req.strip() and not req.startswith("#"):
+                    if not set(">=<") & set(req):
+                        # PyPI requirement without version.
+                        break
+            else:
+                # All requirements are pinned.
+                return
+        pip("-r %s/%s" % (env.proj_path, env.reqs_path))
+
+
+###########################################
+# Utils and wrappers for various commands #
+###########################################
+
+def _print(output):
+    print()
+    print(output)
+    print()
+
+
+def print_command(command):
+    _print(blue("$ ", bold=True) +
+           yellow(command, bold=True) +
+           red(" ->", bold=True))
+
+
+@task
+def run(command, show=True):
+    """
+    Runs a shell comand on the remote server.
+    """
+    if show:
+        print_command(command)
+    with hide("running"):
+        return _run(command)
+
+
+@task
+def sudo(command, show=True):
+    """
+    Runs a command as sudo.
+    """
+    if show:
+        print_command(command)
+    with hide("running"):
+        return _sudo(command)
+
+
+def log_call(func):
+    @wraps(func)
+    def logged(*args, **kawrgs):
+        header = "-" * len(func.__name__)
+        _print(green("\n".join([header, func.__name__, header]), bold=True))
+        return func(*args, **kawrgs)
+    return logged
+
+
+def get_templates():
+    """
+    Returns each of the templates with env vars injected.
+    """
+    injected = {}
+    for name, data in templates.items():
+        injected[name] = dict([(k, v % env) for k, v in data.items()])
+    return injected
+
+
+def upload_template_and_reload(name):
+    """
+    Uploads a template only if it has changed, and if so, reload a
+    related service.
+    """
+    template = get_templates()[name]
+    local_path = template["local_path"]
+    if not os.path.exists(local_path):
+        project_root = os.path.dirname(os.path.abspath(__file__))
+        local_path = os.path.join(project_root, local_path)
+    remote_path = template["remote_path"]
+    reload_command = template.get("reload_command")
+    owner = template.get("owner")
+    mode = template.get("mode")
+    remote_data = ""
+    if exists(remote_path):
+        with hide("stdout"):
+            remote_data = sudo("cat %s" % remote_path, show=False)
+    with open(local_path, "r") as f:
+        local_data = f.read()
+        # Escape all non-string-formatting-placeholder occurrences of '%':
+        local_data = re.sub(r"%(?!\(\w+\)s)", "%%", local_data)
+        if "%(db_pass)s" in local_data:
+            env.db_pass = db_pass()
+        local_data %= env
+    clean = lambda s: s.replace("\n", "").replace("\r", "").strip()
+    if clean(remote_data) == clean(local_data):
+        return
+    upload_template(local_path, remote_path, env, use_sudo=True, backup=False)
+    if owner:
+        sudo("chown %s %s" % (owner, remote_path))
+    if mode:
+        sudo("chmod %s %s" % (mode, remote_path))
+    if reload_command:
+        sudo(reload_command)
+
+
+def db_pass():
+    """
+    Prompts for the database password if unknown.
+    """
+    if not env.db_pass:
+        env.db_pass = getpass("Enter the database password: ")
+    return env.db_pass
+
+
+@task
+def apt(packages):
+    """
+    Installs one or more system packages via apt.
+    """
+    return sudo("apt-get install -y -q " + packages)
+
+
+@task
+def pip(packages):
+    """
+    Installs one or more Python packages within the virtual environment.
+    """
+    with virtualenv():
+        return sudo("pip install %s" % packages)
+
+
+def postgres(command):
+    """
+    Runs the given command as the postgres user.
+    """
+    show = not command.startswith("psql")
+    return run("sudo -u root sudo -u postgres %s" % command, show=show)
+
+
+@task
+def psql(sql, show=True):
+    """
+    Runs SQL against the project's database.
+    """
+    out = postgres('psql -c "%s"' % sql)
+    if show:
+        print_command(sql)
+    return out
+
+
+@task
+def backup(filename):
+    """
+    Backs up the database.
+    """
+    return postgres("pg_dump -Fc %s > %s" % (env.proj_name, filename))
+
+
+@task
+def restore(filename):
+    """
+    Restores the database.
+    """
+    return postgres("pg_restore -c -d %s %s" % (env.proj_name, filename))
+
+
+@task
+def python(code, show=True):
+    """
+    Runs Python code in the project's virtual environment, with Django loaded.
+    """
+    setup = "import os; os.environ[\'DJANGO_SETTINGS_MODULE\']=\'settings\';"
+    full_code = 'python -c "%s%s"' % (setup, code.replace("`", "\\\`"))
+    with project():
+        result = run(full_code, show=False)
+        if show:
+            print_command(code)
+    return result
+
+
+def static():
+    """
+    Returns the live STATIC_ROOT directory.
+    """
+    return python("from django.conf import settings;"
+                  "print settings.STATIC_ROOT", show=False).split("\n")[-1]
+
+
+@task
+def manage(command):
+    """
+    Runs a Django management command.
+    """
+    return run("%s %s" % (env.manage, command))
+
+
+#########################
+# Install and configure #
+#########################
+
+@task
+@log_call
+def install():
+    """
+    Installs the base system and Python requirements for the entire server.
+    """
+    locale = "LC_ALL=%s" % env.locale
+    with hide("stdout"):
+        if locale not in sudo("cat /etc/default/locale"):
+            sudo("update-locale %s" % locale)
+            run("exit")
+    sudo("apt-get update -y -q")
+    apt("nginx libjpeg-dev python-dev python-setuptools git-core "
+        "postgresql libpq-dev memcached supervisor")
+    sudo("easy_install pip")
+    sudo("pip install virtualenv mercurial")
+
+
+@task
+@log_call
+def create():
+    """
+    Create a new virtual environment for a project.
+    Pulls the project's repo from version control, adds system-level
+    configs for the project, and initialises the database with the
+    live host.
+    """
+
+    # Create virtualenv
+    with cd(env.venv_home):
+        if exists(env.proj_name):
+            prompt = input("\nVirtualenv exists: %s"
+                           "\nWould you like to replace it? (yes/no) "
+                           % env.proj_name)
+            if prompt.lower() != "yes":
+                print("\nAborting!")
+                return False
+            remove()
+        run("virtualenv %s --distribute" % env.proj_name)
+        vcs = "git" if env.git else "hg"
+        run("%s clone %s %s" % (vcs, env.repo_url, env.proj_path))
+
+    # Create DB and DB user.
+    pw = db_pass()
+    user_sql_args = (env.proj_name, pw.replace("'", "\'"))
+    user_sql = "CREATE USER %s WITH ENCRYPTED PASSWORD '%s';" % user_sql_args
+    psql(user_sql, show=False)
+    shadowed = "*" * len(pw)
+    print_command(user_sql.replace("'%s'" % pw, "'%s'" % shadowed))
+    psql("CREATE DATABASE %s WITH OWNER %s ENCODING = 'UTF8' "
+         "LC_CTYPE = '%s' LC_COLLATE = '%s' TEMPLATE template0;" %
+         (env.proj_name, env.proj_name, env.locale, env.locale))
+
+    # Set up SSL certificate.
+    if not env.ssl_disabled:
+        conf_path = "/etc/nginx/conf"
+        if not exists(conf_path):
+            sudo("mkdir %s" % conf_path)
+        with cd(conf_path):
+            crt_file = env.proj_name + ".crt"
+            key_file = env.proj_name + ".key"
+            if not exists(crt_file) and not exists(key_file):
+                try:
+                    crt_local, = glob(join("deploy", "*.crt"))
+                    key_local, = glob(join("deploy", "*.key"))
+                except ValueError:
+                    parts = (crt_file, key_file, env.domains[0])
+                    sudo("openssl req -new -x509 -nodes -out %s -keyout %s "
+                         "-subj '/CN=%s' -days 3650" % parts)
+                else:
+                    upload_template(crt_local, crt_file, use_sudo=True)
+                    upload_template(key_local, key_file, use_sudo=True)
+
+    # Set up project.
+    upload_template_and_reload("settings")
+    with project():
+        if env.reqs_path:
+            pip("-r %s/%s" % (env.proj_path, env.reqs_path))
+        pip("gunicorn setproctitle south psycopg2 "
+            "django-compressor python-memcached")
+        manage("createdb --noinput --nodata")
+        python("from django.conf import settings;"
+               "from django.contrib.sites.models import Site;"
+               "Site.objects.filter(id=settings.SITE_ID).update(domain='%s');"
+               % env.domains[0])
+        for domain in env.domains:
+            python("from django.contrib.sites.models import Site;"
+                   "Site.objects.get_or_create(domain='%s');" % domain)
+        if env.admin_pass:
+            pw = env.admin_pass
+            user_py = ("from mezzanine.utils.models import get_user_model;"
+                       "User = get_user_model();"
+                       "u, _ = User.objects.get_or_create(username='admin');"
+                       "u.is_staff = u.is_superuser = True;"
+                       "u.set_password('%s');"
+                       "u.save();" % pw)
+            python(user_py, show=False)
+            shadowed = "*" * len(pw)
+            print_command(user_py.replace("'%s'" % pw, "'%s'" % shadowed))
+
+    return True
+
+
+@task
+@log_call
+def remove():
+    """
+    Blow away the current project.
+    """
+    if exists(env.venv_path):
+        sudo("rm -rf %s" % env.venv_path)
+    for template in get_templates().values():
+        remote_path = template["remote_path"]
+        if exists(remote_path):
+            sudo("rm %s" % remote_path)
+    psql("DROP DATABASE IF EXISTS %s;" % env.proj_name)
+    psql("DROP USER IF EXISTS %s;" % env.proj_name)
+
+
+##############
+# Deployment #
+##############
+
+@task
+@log_call
+def restart():
+    """
+    Restart gunicorn worker processes for the project.
+    """
+    pid_path = "%s/gunicorn.pid" % env.proj_path
+    if exists(pid_path):
+        sudo("kill -HUP `cat %s`" % pid_path)
+    else:
+        start_args = (env.proj_name, env.proj_name)
+        sudo("supervisorctl start %s:gunicorn_%s" % start_args)
+
+
+@task
+@log_call
+def deploy():
+    """
+    Deploy latest version of the project.
+    Check out the latest version of the project from version
+    control, install new requirements, sync and migrate the database,
+    collect any new static assets, and restart gunicorn's work
+    processes for the project.
+    """
+    if not exists(env.venv_path):
+        prompt = input("\nVirtualenv doesn't exist: %s"
+                       "\nWould you like to create it? (yes/no) "
+                       % env.proj_name)
+        if prompt.lower() != "yes":
+            print("\nAborting!")
+            return False
+        create()
+    for name in get_templates():
+        upload_template_and_reload(name)
+    with project():
+        backup("last.db")
+        static_dir = static()
+        if exists(static_dir):
+            run("tar -cf last.tar %s" % static_dir)
+        git = env.git
+        last_commit = "git rev-parse HEAD" if git else "hg id -i"
+        run("%s > last.commit" % last_commit)
+        with update_changed_requirements():
+            run("git pull origin master -f" if git else "hg pull && hg up -C")
+        manage("collectstatic -v 0 --noinput")
+        manage("syncdb --noinput")
+        manage("migrate --noinput")
+    restart()
+    return True
+
+
+@task
+@log_call
+def rollback():
+    """
+    Reverts project state to the last deploy.
+    When a deploy is performed, the current state of the project is
+    backed up. This includes the last commit checked out, the database,
+    and all static files. Calling rollback will revert all of these to
+    their state prior to the last deploy.
+    """
+    with project():
+        with update_changed_requirements():
+            update = "git checkout" if env.git else "hg up -C"
+            run("%s `cat last.commit`" % update)
+        with cd(join(static(), "..")):
+            run("tar -xf %s" % join(env.proj_path, "last.tar"))
+        restore("last.db")
+    restart()
+
+
+@task
+@log_call
+def all():
+    """
+    Installs everything required on a new system and deploy.
+    From the base software, up to the deployed project.
+    """
+    install()
+    if create():
+        deploy()
new file mode 100644
--- /dev/null
+++ b/manage.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+from __future__ import absolute_import, unicode_literals
+
+import os
+import sys
+
+
+# Corrects some pathing issues in various contexts, such as cron jobs,
+# and the project layout still being in Django 1.3 format.
+from settings import PROJECT_ROOT, PROJECT_DIRNAME
+os.chdir(PROJECT_ROOT)
+sys.path.append(os.path.abspath(os.path.join(PROJECT_ROOT, "..")))
+
+
+# Add the site ID CLI arg to the environment, which allows for the site
+# used in any site related queries to be manually set for management
+# commands.
+for i, arg in enumerate(sys.argv):
+    if arg.startswith("--site"):
+        os.environ["MEZZANINE_SITE_ID"] = arg.split("=")[1]
+        sys.argv.pop(i)
+
+
+# Run Django.
+if __name__ == "__main__":
+    settings_module = "%s.settings" % PROJECT_DIRNAME
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module)
+    from django.core.management import execute_from_command_line
+    execute_from_command_line(sys.argv)
new file mode 100644
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,1 @@
+Mezzanine==3.1.4
new file mode 100644
--- /dev/null
+++ b/settings.py
@@ -0,0 +1,364 @@
+from __future__ import absolute_import, unicode_literals
+
+######################
+# MEZZANINE SETTINGS #
+######################
+
+# The following settings are already defined with default values in
+# the ``defaults.py`` module within each of Mezzanine's apps, but are
+# common enough to be put here, commented out, for convenient
+# overriding. Please consult the settings documentation for a full list
+# of settings Mezzanine implements:
+# http://mezzanine.jupo.org/docs/configuration.html#default-settings
+
+# Controls the ordering and grouping of the admin menu.
+#
+# ADMIN_MENU_ORDER = (
+#     ("Content", ("pages.Page", "blog.BlogPost",
+#        "generic.ThreadedComment", ("Media Library", "fb_browse"),)),
+#     ("Site", ("sites.Site", "redirects.Redirect", "conf.Setting")),
+#     ("Users", ("auth.User", "auth.Group",)),
+# )
+
+# A three item sequence, each containing a sequence of template tags
+# used to render the admin dashboard.
+#
+# DASHBOARD_TAGS = (
+#     ("blog_tags.quick_blog", "mezzanine_tags.app_list"),
+#     ("comment_tags.recent_comments",),
+#     ("mezzanine_tags.recent_actions",),
+# )
+
+# A sequence of templates used by the ``page_menu`` template tag. Each
+# item in the sequence is a three item sequence, containing a unique ID
+# for the template, a label for the template, and the template path.
+# These templates are then available for selection when editing which
+# menus a page should appear in. Note that if a menu template is used
+# that doesn't appear in this setting, all pages will appear in it.
+
+# 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"),
+# )
+
+# A sequence of fields that will be injected into Mezzanine's (or any
+# library's) models. Each item in the sequence is a four item sequence.
+# The first two items are the dotted path to the model and its field
+# name to be added, and the dotted path to the field class to use for
+# the field. The third and fourth items are a sequence of positional
+# args and a dictionary of keyword args, to use when creating the
+# field instance. When specifying the field class, the path
+# ``django.models.db.`` can be omitted for regular Django model fields.
+#
+# EXTRA_MODEL_FIELDS = (
+#     (
+#         # Dotted path to field.
+#         "mezzanine.blog.models.BlogPost.image",
+#         # Dotted path to field class.
+#         "somelib.fields.ImageField",
+#         # Positional args for field class.
+#         ("Image",),
+#         # Keyword args for field class.
+#         {"blank": True, "upload_to": "blog"},
+#     ),
+#     # Example of adding a field to *all* of Mezzanine's content types:
+#     (
+#         "mezzanine.pages.models.Page.another_field",
+#         "IntegerField", # 'django.db.models.' is implied if path is omitted.
+#         ("Another name",),
+#         {"blank": True, "default": 1},
+#     ),
+# )
+
+# Setting to turn on featured images for blog posts. Defaults to False.
+#
+# BLOG_USE_FEATURED_IMAGE = True
+
+# If True, the south application will be automatically added to the
+# INSTALLED_APPS setting.
+USE_SOUTH = True
+
+
+########################
+# MAIN DJANGO SETTINGS #
+########################
+
+# People who get code error notifications.
+# In the format (('Full Name', 'email@example.com'),
+#                ('Full Name', 'anotheremail@example.com'))
+ADMINS = (
+    # ('Your Name', 'your_email@domain.com'),
+)
+MANAGERS = ADMINS
+
+# Hosts/domain names that are valid for this site; required if DEBUG is False
+# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
+ALLOWED_HOSTS = []
+
+# Local time zone for this installation. Choices can be found here:
+# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
+# although not all choices may be available on all operating systems.
+# On Unix systems, a value of None will cause Django to use the same
+# timezone as the operating system.
+# If running in a Windows environment this must be set to the same as your
+# system time zone.
+TIME_ZONE = None
+
+# If you set this to True, Django will use timezone-aware datetimes.
+USE_TZ = True
+
+# Language code for this installation. All choices can be found here:
+# http://www.i18nguy.com/unicode/language-identifiers.html
+LANGUAGE_CODE = "en"
+
+# Supported languages
+_ = lambda s: s
+LANGUAGES = (
+    ('en', _('English')),
+)
+
+# A boolean that turns on/off debug mode. When set to ``True``, stack traces
+# are displayed for error pages. Should always be set to ``False`` in
+# production. Best set to ``True`` in local_settings.py
+DEBUG = False
+
+# Whether a user's session cookie expires when the Web browser is closed.
+SESSION_EXPIRE_AT_BROWSER_CLOSE = True
+
+SITE_ID = 1
+
+# If you set this to False, Django will make some optimizations so as not
+# to load the internationalization machinery.
+USE_I18N = False
+
+# Tuple of IP addresses, as strings, that:
+#   * See debug comments, when DEBUG is true
+#   * Receive x-headers
+INTERNAL_IPS = ("127.0.0.1",)
+
+# List of callables that know how to import templates from various sources.
+TEMPLATE_LOADERS = (
+    "django.template.loaders.filesystem.Loader",
+    "django.template.loaders.app_directories.Loader",
+)
+
+AUTHENTICATION_BACKENDS = ("mezzanine.core.auth_backends.MezzanineBackend",)
+
+# List of finder classes that know how to find static files in
+# various locations.
+STATICFILES_FINDERS = (
+    "django.contrib.staticfiles.finders.FileSystemFinder",
+    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
+#    'django.contrib.staticfiles.finders.DefaultStorageFinder',
+)
+
+# The numeric mode to set newly-uploaded files to. The value should be
+# a mode you'd pass directly to os.chmod.
+FILE_UPLOAD_PERMISSIONS = 0o644
+
+
+#############
+# DATABASES #
+#############
+
+DATABASES = {
+    "default": {
+        # Add "postgresql_psycopg2", "mysql", "sqlite3" or "oracle".
+        "ENGINE": "django.db.backends.",
+        # DB name or path to database file if using sqlite3.
+        "NAME": "",
+        # Not used with sqlite3.
+        "USER": "",
+        # Not used with sqlite3.
+        "PASSWORD": "",
+        # Set to empty string for localhost. Not used with sqlite3.
+        "HOST": "",
+        # Set to empty string for default. Not used with sqlite3.
+        "PORT": "",
+    }
+}
+
+
+#########
+# PATHS #
+#########
+
+import os
+
+# Full filesystem path to the project.
+PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
+
+# Name of the directory for the project.
+PROJECT_DIRNAME = PROJECT_ROOT.split(os.sep)[-1]
+
+# Every cache key will get prefixed with this value - here we set it to
+# the name of the directory the project is in to try and use something
+# project specific.
+CACHE_MIDDLEWARE_KEY_PREFIX = PROJECT_DIRNAME
+
+# URL prefix for static files.
+# Example: "http://media.lawrence.com/static/"
+STATIC_URL = "/static/"
+
+# Absolute path to the directory static files should be collected to.
+# Don't put anything in this directory yourself; store your static files
+# in apps' "static/" subdirectories and in STATICFILES_DIRS.
+# Example: "/home/media/media.lawrence.com/static/"
+STATIC_ROOT = os.path.join(PROJECT_ROOT, STATIC_URL.strip("/"))
+
+# URL that handles the media served from MEDIA_ROOT. Make sure to use a
+# trailing slash.
+# Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
+MEDIA_URL = STATIC_URL + "media/"
+
+# Absolute filesystem path to the directory that will hold user-uploaded files.
+# Example: "/home/media/media.lawrence.com/media/"
+MEDIA_ROOT = os.path.join(PROJECT_ROOT, *MEDIA_URL.strip("/").split("/"))
+
+# Package/module name to import the root urlpatterns from for the project.
+ROOT_URLCONF = "%s.urls" % PROJECT_DIRNAME
+
+# Put strings here, like "/home/html/django_templates"
+# or "C:/www/django/templates".
+# Always use forward slashes, even on Windows.
+# Don't forget to use absolute paths, not relative paths.
+TEMPLATE_DIRS = (os.path.join(PROJECT_ROOT, "templates"),)
+
+
+################
+# APPLICATIONS #
+################
+
+INSTALLED_APPS = (
+    "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.blog",
+    "mezzanine.forms",
+    "mezzanine.pages",
+    "mezzanine.galleries",
+    "mezzanine.twitter",
+    #"mezzanine.accounts",
+    #"mezzanine.mobile",
+)
+
+# List of processors used by RequestContext to populate the context.
+# Each one should be a callable that takes the request object as its
+# only parameter and returns a dictionary to add to the context.
+TEMPLATE_CONTEXT_PROCESSORS = (
+    "django.contrib.auth.context_processors.auth",
+    "django.contrib.messages.context_processors.messages",
+    "django.core.context_processors.debug",
+    "django.core.context_processors.i18n",
+    "django.core.context_processors.static",
+    "django.core.context_processors.media",
+    "django.core.context_processors.request",
+    "django.core.context_processors.tz",
+    "mezzanine.conf.context_processors.settings",
+    "mezzanine.pages.context_processors.page",
+)
+
+# List of middleware classes to use. Order is important; in the request phase,
+# these middleware classes will be applied in the order given, and in the
+# response phase the middleware will be applied in reverse order.
+MIDDLEWARE_CLASSES = (
+    "mezzanine.core.middleware.UpdateCacheMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.locale.LocaleMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "mezzanine.core.request.CurrentRequestMiddleware",
+    "mezzanine.core.middleware.RedirectFallbackMiddleware",
+    "mezzanine.core.middleware.TemplateForDeviceMiddleware",
+    "mezzanine.core.middleware.TemplateForHostMiddleware",
+    "mezzanine.core.middleware.AdminLoginInterfaceSelectorMiddleware",
+    "mezzanine.core.middleware.SitePermissionMiddleware",
+    # Uncomment the following if using any of the SSL settings:
+    # "mezzanine.core.middleware.SSLRedirectMiddleware",
+    "mezzanine.pages.middleware.PageMiddleware",
+    "mezzanine.core.middleware.FetchFromCacheMiddleware",
+)
+
+# Store these package names here as they may change in the future since
+# at the moment we are using custom forks of them.
+PACKAGE_NAME_FILEBROWSER = "filebrowser_safe"
+PACKAGE_NAME_GRAPPELLI = "grappelli_safe"
+
+#########################
+# OPTIONAL APPLICATIONS #
+#########################
+
+# These will be added to ``INSTALLED_APPS``, only if available.
+OPTIONAL_APPS = (
+    "debug_toolbar",
+    "django_extensions",
+    "compressor",
+    PACKAGE_NAME_FILEBROWSER,
+    PACKAGE_NAME_GRAPPELLI,
+)
+
+###################
+# DEPLOY SETTINGS #
+###################
+
+# These settings are used by the default fabfile.py provided.
+# Check fabfile.py for defaults.
+
+# FABRIC = {
+#     "SSH_USER": "", # SSH username for host deploying to
+#     "HOSTS": ALLOWED_HOSTS[:1], # List of hosts to deploy to (eg, first host)
+#     "DOMAINS": ALLOWED_HOSTS, # Domains for public site
+#     "REPO_URL": "ssh://hg@bitbucket.org/user/project", # Project's repo URL
+#     "VIRTUALENV_HOME":  "", # Absolute remote path for virtualenvs
+#     "PROJECT_NAME": "", # Unique identifier for project
+#     "REQUIREMENTS_PATH": "requirements.txt", # Project's pip requirements
+#     "GUNICORN_PORT": 8000, # Port gunicorn will listen on
+#     "LOCALE": "en_US.UTF-8", # Should end with ".UTF-8"
+#     "DB_PASS": "", # Live database password
+#     "ADMIN_PASS": "", # Live admin user password
+#     "SECRET_KEY": SECRET_KEY,
+#     "NEVERCACHE_KEY": NEVERCACHE_KEY,
+# }
+
+
+##################
+# LOCAL SETTINGS #
+##################
+
+# Allow any settings to be defined in local_settings.py which should be
+# ignored in your version control system allowing for settings to be
+# defined per machine.
+try:
+    from local_settings import *
+except ImportError:
+    pass
+
+
+####################
+# DYNAMIC SETTINGS #
+####################
+
+# set_dynamic_settings() will rewrite globals based on what has been
+# defined so far, in order to provide some better defaults where
+# applicable. We also allow this settings module to be imported
+# without Mezzanine installed, as the case may be when using the
+# fabfile, where setting the dynamic settings below isn't strictly
+# required.
+try:
+    from mezzanine.utils.conf import set_dynamic_settings
+except ImportError:
+    pass
+else:
+    set_dynamic_settings(globals())
new file mode 100644
--- /dev/null
+++ b/urls.py
@@ -0,0 +1,95 @@
+from __future__ import unicode_literals
+
+from django.conf.urls import patterns, include, url
+from django.conf.urls.i18n import i18n_patterns
+from django.contrib import admin
+
+from mezzanine.core.views import direct_to_template
+
+
+admin.autodiscover()
+
+# Add the urlpatterns for any custom Django applications here.
+# You can also change the ``home`` view to add your own functionality
+# to the project's homepage.
+
+urlpatterns = i18n_patterns("",
+    # Change the admin prefix here to use an alternate URL for the
+    # admin interface, which would be marginally more secure.
+    ("^admin/", include(admin.site.urls)),
+)
+
+urlpatterns += patterns('',
+
+    # We don't want to presume how your homepage works, so here are a
+    # few patterns you can use to set it up.
+
+    # HOMEPAGE AS STATIC TEMPLATE
+    # ---------------------------
+    # This pattern simply loads the index.html template. It isn't
+    # commented out like the others, so it's the default. You only need
+    # one homepage pattern, so if you use a different one, comment this
+    # one out.
+
+    url("^$", direct_to_template, {"template": "index.html"}, name="home"),
+
+    # HOMEPAGE AS AN EDITABLE PAGE IN THE PAGE TREE
+    # ---------------------------------------------
+    # This pattern gives us a normal ``Page`` object, so that your
+    # homepage can be managed via the page tree in the admin. If you
+    # use this pattern, you'll need to create a page in the page tree,
+    # and specify its URL (in the Meta Data section) as "/", which
+    # is the value used below in the ``{"slug": "/"}`` part.
+    # Also note that the normal rule of adding a custom
+    # template per page with the template name using the page's slug
+    # doesn't apply here, since we can't have a template called
+    # "/.html" - so for this case, the template "pages/index.html"
+    # should be used if you want to customize the homepage's template.
+
+    # url("^$", "mezzanine.pages.views.page", {"slug": "/"}, name="home"),
+
+    # HOMEPAGE FOR A BLOG-ONLY SITE
+    # -----------------------------
+    # This pattern points the homepage to the blog post listing page,
+    # and is useful for sites that are primarily blogs. If you use this
+    # pattern, you'll also need to set BLOG_SLUG = "" in your
+    # ``settings.py`` module, and delete the blog page object from the
+    # page tree in the admin if it was installed.
+
+    # url("^$", "mezzanine.blog.views.blog_post_list", name="home"),
+
+    # MEZZANINE'S URLS
+    # ----------------
+    # ADD YOUR OWN URLPATTERNS *ABOVE* THE LINE BELOW.
+    # ``mezzanine.urls`` INCLUDES A *CATCH ALL* PATTERN
+    # FOR PAGES, SO URLPATTERNS ADDED BELOW ``mezzanine.urls``
+    # WILL NEVER BE MATCHED!
+
+    # If you'd like more granular control over the patterns in
+    # ``mezzanine.urls``, go right ahead and take the parts you want
+    # from it, and use them directly below instead of using
+    # ``mezzanine.urls``.
+    ("^", include("mezzanine.urls")),
+
+    # MOUNTING MEZZANINE UNDER A PREFIX
+    # ---------------------------------
+    # You can also mount all of Mezzanine's urlpatterns under a
+    # URL prefix if desired. When doing this, you need to define the
+    # ``SITE_PREFIX`` setting, which will contain the prefix. Eg:
+    # SITE_PREFIX = "my/site/prefix"
+    # For convenience, and to avoid repeating the prefix, use the
+    # commented out pattern below (commenting out the one above of course)
+    # which will make use of the ``SITE_PREFIX`` setting. Make sure to
+    # add the import ``from django.conf import settings`` to the top
+    # of this file as well.
+    # Note that for any of the various homepage patterns above, you'll
+    # need to use the ``SITE_PREFIX`` setting as well.
+
+    # ("^%s/" % settings.SITE_PREFIX, include("mezzanine.urls"))
+
+)
+
+# Adds ``STATIC_URL`` to the context of error pages, so that error
+# pages can use JS, CSS and images.
+handler404 = "mezzanine.core.views.page_not_found"
+handler500 = "mezzanine.core.views.server_error"
new file mode 100644
--- /dev/null
+++ b/wsgi.py
@@ -0,0 +1,10 @@
+from __future__ import unicode_literals
+
+import os
+
+PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
+settings_module = "%s.settings" % PROJECT_ROOT.split(os.sep)[-1]
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module)
+
+from django.core.wsgi import get_wsgi_application
+application = get_wsgi_application()