Mercurial > hg > stickjan
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 --- /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/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()