def setup_log_files_owner():
"""
Runs django manage.py check command and sets logs folder owner after
"""
django_manage('check')
sudo('chown -R {user}:{group} {logpath}'.format(
user=ctx('system.user'),
group=ctx('system.group'),
logpath=ctx('logs.dirs.root')))
def setup_settings():
"""
Takes the dploy/<STAGE>_settings.py template and upload it to remote
django project location (as local_settings.py)
"""
print(cyan("Setuping django settings project on {}".format(env.stage)))
project_dir = get_project_dir()
project_name = ctx('django.project_name')
stage_settings = '{stage}_settings.py'.format(stage=env.stage)
templates = [
os.path.join('./dploy/', stage_settings),
os.path.join('./', project_name, 'local_settings.py-dist'),
os.path.join('./', project_name, 'local_settings.py-default'),
os.path.join('./', project_name, 'local_settings.py-example'),
os.path.join('./', project_name, 'local_settings.py.dist'),
os.path.join('./', project_name, 'local_settings.py.default'),
os.path.join('./', project_name, 'local_settings.py.example'),
]
template = select_template(templates)
if not template:
print(red('ERROR: the project does not have a settings template'))
print("The project must provide at least one of these file:")
print("\n - {}\n".format("\n - ".join(templates)))
sys.exit(1)
filename = os.path.basename(template)
templates_dir = os.path.dirname(template)
_settings_dest = os.path.join(project_dir, project_name,
'local_settings.py')
upload_template(filename, _settings_dest, template_dir=templates_dir)
def install_requirements(upgrade=False, upgrade_strategy='only-if-needed'):
"""
Installs pip requirements
"""
project_dir = get_project_dir()
requirements_pip = os.path.join(project_dir, 'requirements.pip')
# it is necessary to cd into project dir to support relative
# paths inside requirements correctly
with cd(project_dir):
if files.exists(requirements_pip, use_sudo=True):
print(cyan("Installing requirements.pip on {}".format(env.stage)))
with _virtualenv(env.venv_path):
_install_requirements(
requirements_pip, upgrade=upgrade, use_sudo=True,
upgrade_strategy=upgrade_strategy)
requirements_txt = os.path.join(project_dir, 'requirements.txt')
if files.exists(requirements_txt, use_sudo=True):
print(cyan("Installing requirements.txt on {}".format(env.stage)))
with _virtualenv(env.venv_path):
_install_requirements(
requirements_txt, upgrade=upgrade, use_sudo=True,
upgrade_strategy=upgrade_strategy)
extra_requirements = ctx('virtualenv.extra_requirements',
default=False)
if extra_requirements and isinstance(extra_requirements, list):
for req in extra_requirements:
print(cyan("Installing {} on {}".format(req, env.stage)))
with _virtualenv(env.venv_path):
if req.startswith('./'):
req = os.path.join(project_dir, req[:2])
fabtools.python.install(req, use_sudo=True)
def setup():
"""
Configure uWSGI
"""
print(cyan('Configuring uwsgi {}'.format(env.stage)))
project_dir = get_project_dir()
wsgi_file = os.path.join(project_dir, ctx('django.project_name'),
'wsgi.py')
uwsgi_ini = os.path.join(project_dir, 'uwsgi.ini')
context = {'ctx': ctx, 'project_dir': project_dir, 'wsgi_file': wsgi_file}
log_file = '{}/uwsgi.log'.format(ctx('logs.dirs.root'))
sudo('touch {logfile}'.format(logfile=log_file))
sudo('chown {user}:{group} {logfile}'.format(logfile=log_file,
user=ctx('system.user'),
group=ctx('system.group')))
upload_template('uwsgi.template', uwsgi_ini, context=context)
def create_dirs():
"""
Creates necessary directories and apply user/group permissions
"""
paths = []
print(cyan('Creating directories on {}'.format(env.stage)))
for k in env.context.keys():
if type(env.context.get(k)) is dict:
dirs = env.context.get(k).get('dirs')
if dirs:
for name, path in dirs.items():
p = Template(path).render(**env.context)
paths.append(p)
out = ' '.join(paths)
sudo('mkdir -p {paths}'.format(paths=out))
sudo('chown -R {user}:{group} {paths}'.format(
user=ctx('system.user'), group=ctx('system.group'), paths=out))
def setup():
"""
Configure Cron if a dploy/cron.template exists
"""
# Cron doesn't like dots in filename
filename = ctx('nginx.server_name').replace('.', '_')
dest = os.path.join(ctx('cron.config_path'), filename)
try:
upload_template('cron.template', dest)
print(cyan('Configuring cron {}'.format(env.stage)))
# We make sure the cron file always ends with a blank line, otherwise
# it will be ignored by cron. Yeah, that's retarded.
sudo("echo -en '\n' >> {}".format(dest))
sudo('chown -R root:root {}'.format(dest))
sudo('chmod 644 {}'.format(dest))
except TemplateNotFound:
print(yellow('Skipping cron configuration on {}'.format(env.stage)))
def setup(upgrade=False, upgrade_strategy='only-if-needed'):
"""
Setup virtualenv on the remote location
"""
venv_root = ctx('virtualenv.dirs.root')
venv_name = ctx('virtualenv.name')
venv_path = os.path.join(venv_root, venv_name)
py = 'python{}'.format(ctx('python.version'))
env.venv_path = venv_path
if not fabtools.deb.is_installed('python-virtualenv'):
fabtools.deb.install('python-virtualenv')
# Experimental
require.python.virtualenv(
venv_path, python_cmd=py, use_sudo=True, venv_python=py)
with _virtualenv(venv_path):
require.python.pip()
require.python.setuptools()
execute(install_requirements, upgrade=upgrade, upgrade_strategy=upgrade_strategy)
def setup():
"""
Configure supervisor to monitor the uwsgi process
"""
print(cyan('Configuring supervisor {}'.format(env.stage)))
if not fabtools.deb.is_installed('supervisor'):
fabtools.deb.install('supervisor')
project_dir = get_project_dir()
uwsgi_ini = os.path.join(project_dir, 'uwsgi.ini')
name = ctx('supervisor.program_name')
context = {'uwsgi_ini': uwsgi_ini}
dest = os.path.join(
ctx('supervisor.dirs.root'),
'{}.conf'.format(ctx('nginx.server_name').replace('.', '_')))
upload_template('supervisor.template', dest, context=context)
fabtools.supervisor.update_config()
if fabtools.supervisor.process_status(name) == 'RUNNING':
fabtools.supervisor.restart_process(name)
elif fabtools.supervisor.process_status(name) == 'STOPPED':
fabtools.supervisor.start_process(name)
def install_dependencies():
"""
Install system dependencies (dploy.yml:system.packages)
"""
deps = ctx('system.packages')
if deps:
_cmd = 'apt-get install -qy {}'.format(deps.replace('\\\n', ''))
print(cyan('Installing system dependencies on {}'.format(env.stage)))
if len(env.hosts) == 0 and env.stage == 'dev':
local(_cmd)
else:
sudo(_cmd)
def checkout():
"""
Checkouts the code on the remote location using git
"""
branch = ctx('git.branch')
git_root = ctx('git.dirs.root')
git_dir = git_dirname(ctx('git.repository'))
git_path = os.path.join(git_root, git_dir)
if not fabtools.deb.is_installed('git'):
fabtools.deb.install('git')
print(
cyan('Checking out {} @ {} -> {}'.format(branch, ctx('git.repository'),
git_path)))
# Experimental
require.git.working_copy(ctx('git.repository'),
path=git_path,
branch=branch,
update=True,
use_sudo=True)
with cd(git_path):
sudo('git submodule update --init --recursive')
sudo("find . -iname '*.pyc' | xargs rm -f")
def setup():
"""
Configure SSL with letsencrypt's certbot for the domain
"""
server_name = ctx("nginx.server_name")
path_letsencrypt = '/etc/letsencrypt/live'
path_dhparams = '/etc/letsencrypt/ssl-dhparams.pem'
path_key = '{}/{}/privkey.pem'.format(path_letsencrypt, server_name)
path_cert = '{}/{}/fullchain.pem'.format(path_letsencrypt, server_name)
if not fabtools.deb.is_installed('certbot'):
execute(install)
if not files.exists('/etc/letsencrypt/ssl-dhparams.pem', use_sudo=True):
sudo('openssl dhparam -out /etc/letsencrypt/ssl-dhparams.pem 2048')
if not files.exists('/etc/letsencrypt/options-ssl-nginx.conf',
use_sudo=True):
upload_template('options-ssl-nginx.conf.template',
'/etc/letsencrypt/options-ssl-nginx.conf')
if not files.exists(path_cert, use_sudo=True):
upload_template('nginx_letsencrypt_init.template',
ctx('nginx.config_path'))
sudo('certbot --authenticator webroot --installer nginx -d {}'.format(
server_name))
upload_template('nginx_letsencrypt.template',
ctx('nginx.config_path'),
context={
'ssl': {
'letsencrypt': True,
'dhparams': path_dhparams,
'key': path_key,
'cert': path_cert,
}
})
def setup():
"""
Create context on remote stage (not functional yet)
"""
print(cyan('Configuring context on {}'.format(env.stage)))
if env.stage == 'dev':
abort(red('This task is only for remote stages.'))
context_path = '/root/.context/{project}/{stage}.yml'.format(
**{
'project': ctx('django.project_name'),
'stage': env.stage,
})
if files.exists(context_path, use_sudo=True):
# TODO: interactive edit
# http://klenwell.com/is/FabricEditRemoteFile
print('Context already exists')
else:
# TODO: use prompt to fill in context interactively
with tempfile.TemporaryFile() as tmp:
tmp.write('CONTEXT_TEMPLATE')
def setup():
"""
Configure nginx, will trigger letsencrypt setup if required
"""
print(cyan('Configuring nginx on {}'.format(env.stage)))
context = {
'ssl_letsencrypt': False,
'ssl_with_dhparam': False,
'ssl_cert': None,
'ssl_key': None,
}
if ctx('ssl.letsencrypt'):
execute('letsencrypt.setup')
elif ctx('ssl.key') and ctx('ssl.cert'):
ssl = True
dhparams = ctx('ssl.dhparam', default=False)
key = ctx('ssl.key', default=False)
cert = ctx('ssl.cert', default=False)
if key and files.exists(key, use_sudo=True):
context['ssl_key'] = ctx('ssl.key')
if cert and files.exists(cert, use_sudo=True):
context['ssl_cert'] = ctx('ssl.cert')
if dhparams and files.exists(dhparams, use_sudo=True):
context['ssl_with_dhparam'] = True
if ssl:
upload_template(
'nginx_ssl.template', ctx('nginx.config_path'), context=context)
else:
upload_template(
'nginx.template', ctx('nginx.config_path'), context=context)
if files.exists(ctx('nginx.document_root'), use_sudo=True):
sudo('chown -R {user}:{group} {path}'.format(
path=ctx('nginx.document_root'), user=ctx('system.user'),
group=ctx('system.group')))
sudo('service nginx reload')
def collectstatic():
"""
Collect static medias
"""
print(cyan("Django collectstatic on {}".format(env.stage)))
django_manage(ctx('django.commands.collectstatic'))
def venv(i):
venv_path = os.path.join(ctx('virtualenv.dirs.root'),
ctx('virtualenv.name'))
with cd(get_project_dir()):
return sudo('{}/bin/{}'.format(venv_path, i))
def python(i):
if ctx('python.version') == 3:
return venv('python3 {}'.format(i))
else:
return venv('python2 {}'.format(i))
def python(i):
if str(ctx('python.version')).startswith('3'):
return venv('python3 {}'.format(i))
else:
return venv('python2 {}'.format(i))
