def local_setup():
"Generate {{ project_name }}/settings.py and $VIRTUAL_ENV/bin hooks"
require(
'gemset_fp', 'guard_fp', 'name', 'settings_fp', 'template_dir',
'virtual_env'
)
with open(env.settings_fp, 'w+') as of:
of.write(render_settings())
generated(env.settings_fp)
with open(env.gemset_fp, 'w+') as of:
of.write(env.name)
generated(env.gemset_fp)
with open(env.guard_fp, 'w+') as of:
of.write(render_template(join(env.template_dir, 'Guardfile'), env))
generated(env.guard_fp)
ve_bin = join(env.virtual_env, 'bin')
for hook in ('postactivate', 'postdeactivate'):
hook_file = join(ve_bin, hook)
with open(hook_file, 'w+') as of:
of.write(render_template(join(env.template_dir, hook), env))
generated(hook_file)
django.project(env.name)
from django.conf import settings
local('mkdir -p {}'.format(settings.STATIC_ROOT))
created(settings.STATIC_ROOT)
def wrapper(*args, **kwargs):
django.project(DJANGO_PROJECT_NAME)
if LOCAL_CWD_PATH not in sys.path:
sys.path.insert(0, LOCAL_CWD_PATH)
return fn(*args, **kwargs)
def import_django_settings(self):
sys.path.append(os.getcwd())
django.project(env.project_path_name)
from django.conf import settings
return settings
def prepare_django_conf(environment):
local_project_path = (os.path.sep).join(os.path.dirname(__file__).split(os.path.sep)[0:-1])
sys.path.append(environment.SITE_ROOT)
sys.path.append(local_project_path)
os.environ['SuppressLogging'] = 'true' # only key existense is checked
os.environ['EnvironmentType'] = environment.NAME
django.project('portal')
def import_django_settings(self):
sys.path.append(os.getcwd())
django.project(env.project_path_name)
from django.conf import settings
return settings
def local_setup():
"Generate {{ project_name }}/settings.py and $VIRTUAL_ENV/bin hooks"
require('gemset_fp', 'guard_fp', 'name', 'settings_fp', 'template_dir',
'virtual_env')
with open(env.settings_fp, 'w+') as of:
of.write(render_settings())
generated(env.settings_fp)
with open(env.gemset_fp, 'w+') as of:
of.write(env.name)
generated(env.gemset_fp)
with open(env.guard_fp, 'w+') as of:
of.write(render_template(join(env.template_dir, 'Guardfile'), env))
generated(env.guard_fp)
ve_bin = join(env.virtual_env, 'bin')
for hook in ('postactivate', 'postdeactivate'):
hook_file = join(ve_bin, hook)
with open(hook_file, 'w+') as of:
of.write(render_template(join(env.template_dir, hook), env))
generated(hook_file)
django.project(env.name)
from django.conf import settings
local('mkdir -p {}'.format(settings.STATIC_ROOT))
created(settings.STATIC_ROOT)
def mysqldump_backup():
django.project('config.settings.%s' % env.environment)
from django.conf import settings
command = ('./mysqldump -u %s -p=%s %s > /tmp/cirujanos_dump.json')
command_params = (settings.DATABASE_USER,
settings.DATABASE_PASSWORD,
settings.DATABASE_NAME)
sudo_command(command, command_params)
def sync_from_remote_db():
"""
Gets and imports the remote database
TODO: get the project settings import to work
"""
import os
with lcd(os.path.abspath(__FILE__)):
from fabric.contrib import django
django.project('rise')
def _pg_dump_for_apps(func, dumpfile, *apps):
if not apps:
abort('Must specify at least one Django app.')
_django.project('etsidata')
tables = []
from django.db.models import get_app, get_models
for app in [get_app(a) for a in apps]:
tables.extend([m._meta.db_table for m in get_models(
app, include_auto_created=True)])
execute(func, dumpfile, *tables)
def _pg_dump_for_apps(func, dumpfile, *apps):
if not apps:
abort('Must specify at least one Django app.')
_django.project('etsidata')
tables = []
from django.db.models import get_app, get_models
for app in [get_app(a) for a in apps]:
tables.extend([
m._meta.db_table
for m in get_models(app, include_auto_created=True)
])
execute(func, dumpfile, *tables)
def __init__(self, project_paths, project_package, test_settings=None,
strict=False, restart_command=None,
loaddata_command='loaddata', dumpdata_command='dumpdata',
requirements=None):
self.project_paths = project_paths
self.project_package = project_package
self.test_settings = test_settings
self.strict = strict
self.restart_command = restart_command
self.loaddata_command = loaddata_command
self.dumpdata_command = dumpdata_command
self.requirements = requirements or self.requirements
django.project(project_package)
def __init__(self, project_paths, project_package, test_settings=None,
strict=False, restart_command=None,
loaddata_command='loaddata', dumpdata_command='dumpdata',
requirements=None, local_tables_to_flush=[]):
self.project_paths = project_paths
self.project_package = project_package
self.test_settings = test_settings
self.strict = strict
self.restart_command = restart_command
self.loaddata_command = loaddata_command
self.dumpdata_command = dumpdata_command
self.local_tables_to_flush = local_tables_to_flush
self.requirements = requirements or self.requirements
django.project(project_package)
def __init__(self, project_paths=None, project_package=None, test_settings=None, strict=False,
restart_command=None, loaddata_command=None, dumpdata_command=None,
requirements=None, local_tables_to_flush=[], urls=None, virtualenv_activate=None):
self.project_paths = project_paths or self.project_paths
self.project_package = project_package or self.project_package
self.test_settings = test_settings or self.test_settings
self.restart_command = restart_command or self.restart_command
self.loaddata_command = loaddata_command or self.loaddata_command
self.dumpdata_command = dumpdata_command or self.dumpdata_command
self.local_tables_to_flush = local_tables_to_flush or self.local_tables_to_flush
self.requirements = requirements or self.requirements
self.strict = strict or self.strict
self.urls = urls or self.urls
self.virtualenv_activate = virtualenv_activate or self.virtualenv_activate
fab_django.project(self.project_package)
def local_production_data_backup(backup_location):
"""Backup database and media files"""
env.backup_location = backup_location
if not exists(env.backup_location):
local('mkdir -p %(backup_location)s' % env)
# backup media files
local("tar cvfz %(backup_location)s/mediafiles.tar.gz -C media/ ." % env)
# backup database
django.project(env.django_project)
from django.conf import settings
env.update(settings.DATABASES['default'])
local('pg_dump -Fc --no-owner --no-acl -p %(PORT)s -U %(USER)s %(NAME)s -f %(backup_location)s/db.sql' % env)
def local_production_data_restore(backup_location):
"""Restore latests database and media files"""
local_clear_database()
env.backup_location = backup_location
if not exists(env.backup_location):
operations.abort(red("No backup yet: %(backup_location)s" % env, bold=True))
# restore static files
local('tar xvfz %(backup_location)s/mediafiles.tar.gz -C media/' % env)
# restore database
django.project(env.django_project)
from django.conf import settings
env.update(settings.DATABASES['default'])
local('pg_restore -Fc --no-acl -e --no-owner -p %(PORT)s -U %(USER)s -d %(NAME)s %(backup_location)s/db.sql' % env)
def __init__(self, dir, remote_dir, name, no_files):
"""
Params:
dir: the local app dir.
remote_dir: the remote app dir.
name: the django project name or package.
"""
self.app_dir = dir
self.app_name = os.path.basename(os.path.normpath(self.app_dir))
self.app_package = name if name else self.app_name
self.app_remote_dir = remote_dir if remote_dir else self.app_name
sys.path.append(self.app_dir)
django.project(self.app_name)
self.db_name = self.app_name
self.no_files = no_files
from quilt import *
from dock.fabfile import *
from fabric.api import task, env, execute, roles
from fabric import operations
from fabric.contrib import django
django.project('openbudgets')
from django.core.management import call_command
from openbudgets.apps.entities.factories import *
from openbudgets.apps.sheets.factories import *
@roles('app')
@task
def mock(amount=300):
utilities.notify(u'Creating some mock objects for the database.')
mock_db(amount)
@roles('db')
@task
def db_put():
utilities.notify(u'Loading a local db dump to the remote dump location.')
execute(remote.db.rebuild)
operations.put('/Users/paulwalsh/Sites/projects/openbudgets/tmp/db_dump.sql',
'/srv/projects/openbudgets/tmp/db_dump.sql')
def mock_db(amount):
import logging
from distutils.util import strtobool
from fabric.api import *
from fabric.contrib import django
logger = logging.getLogger(__name__)
if not os.path.isfile('./fabfile.py'):
print '*****Error, you must be in the root directory for running fab commands*****'
sys.exit(1)
DJANGO_PROJECT = 'looksdigest'
DEFAULT_ENV = 'dev'
django.project(DJANGO_PROJECT)
def booleanize(val):
if type(val) is bool:
return val
return strtobool(val) is 1
def set_fab_env(function):
"""
Custom decorator to import specific env
"""
@task(alias=function.__name__)
def wrap_function(*args, **kwargs):
#coding: utf-8
import os
from random import shuffle
import sys
from fabric.api import *
from fabric.contrib import django
django.project('TestManagement')
django.settings_module('TestManagement.settings')
from django.conf import settings
from dataprocess import DBConnection
from svc.sql import enable_clients_ip_sql, master_ip_sql, locust_master_ip_sql
#----------------------------- general config ----------------------------
#并行模式默认关闭，1.3以上支持, win不支持
env.parallel = False
#关闭默认的hosts去重功能
env.dedupe_hosts = False
#遇到错误只warn而不会abort
env.warn_only = True
#重试连接次数，默认为1
env.connection_attempts = 2
#连接超时，默认10s
env.timeout = 5
#跳过连接失败或报错的host
env.skip_bad_hosts = True
env.keepalive = 10
env.use_shell = False
def populate_demo(name):
django.project('get2')
from get2.persone.models import Persona
for i in Persona.objects.all():
print(i)
from fabric.api import local, task, prefix, run, sudo, env, require, cd, quiet
from fabric.colors import green, yellow
from fabric.contrib import django
from functools import wraps
import sys
import os.path
from getpass import getuser
from socket import gethostname
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('chopin')
from django.conf import settings
REPOSITORY = 'https://scm.cch.kcl.ac.uk/hg/chopin-django'
env.user = settings.FABRIC_USER
env.hosts = ['ocve3.dighum.kcl.ac.uk']
env.root_path = '/vol/ocve3/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from fabric.api import task, prefix, run, sudo, env, require, cd, quiet
from fabric.colors import green, yellow
from fabric.contrib import django
from functools import wraps
import sys
import os.path
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('pbw')
from django.conf import settings
REPOSITORY = 'github.com/kingsdigitallab/pbw-django.git'
env.user = settings.FABRIC_USER
env.hosts = ['pbw2.kdl.kcl.ac.uk']
env.gateway = 'ssh.cch.kcl.ac.uk'
env.root_path = '/vol/pbw2/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
env.solr='solr-4.10.4'
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
import os
from fabric.api import local, task, abort, puts, settings
from fabric.contrib import django
# ------------------------------
# Fabric management functions
# ------------------------------
HEROKU_APP = 'foodcast-next'
DJANGO_PROJECT = 'nextmng'
django.project(DJANGO_PROJECT)
BACKUP_DIR = './backups'
BACKUP_PATH = os.path.join(BACKUP_DIR, 'pgdump.db')
# Needed for Ubuntu multi-tenant setup.
# NOTE: this has to match with the db specified in local settings.
DB_CLUSTER = '9.2/main'
########################################################################
# Utility funcitons for files
########################################################################
def booleanize(value):
"""Return value as a boolean."""
true_values = ("yes", "true", "1", "y")
false_values = ("no", "false", "0", "n")
if isinstance(value, bool):
return value
import getpass
import json
import os
import sys
import requests
from fabric.api import env, lcd, local, run, sudo
from fabric.context_managers import cd, hide, quiet, settings
from fabric.contrib import django
from fabric.contrib.files import exists
from fabric.operations import put
import pendulum
django.project('Lunchbreak')
django.settings_module('lunchbreak.Lunchbreak.settings')
started_at = pendulum.now()
# Host
HOST = os.environ.get('LUNCHBREAK_HOST')
HOST = '127.0.0.1'
if not HOST:
HOST = input('Host: ')
# Fabric environment
env.hosts = [HOST]
env.user = '******'
env.shell = '/bin/bash -c -l'
# Git information
with hide('running', 'output'):
with settings(warn_only=True), hide('warnings'):
from fabric.api import run, local, hosts, cd
from fabric.contrib import django
django.project('viewcount')
def hello():
print("Hello Fabric")
def local_deploy():
local("./manage.py runserver")
'hg': 'stable',
'git': 'master'
},
'staging': {
'hg': 'default',
'git': 'develop',
}
}
env.vcs = 'git'
env.vcs_commands = {
'hg': 'hg pull && hg up -C %(branch)s',
'git': 'export GIT_WORK_TREE=%(deploy_dir)s && git checkout -f %(branch)s && git pull',
}
# django integration for access to settings, etc.
django.project(env.project_name)
from django.conf import settings as vcweb_settings
"""
this currently only works for sqlite3 development database. do it by hand with
postgres a few times to figure out what to automate.
"""
syncdb_commands = [
'%(python)s manage.py syncdb --noinput --database=%(database)s' % env,
'%(python)s manage.py migrate' % env,
]
@hosts('dev.commons.asu.edu')
@task
#!/usr/bin/env python
from fabric.api import local, require, settings, task
from fabric.state import env
from termcolor import colored
from fabric.contrib import django
django.project('carebot')
import django
django.setup()
import app_config
# Other fabfiles
import data
import utils
if app_config.DEPLOY_TO_SERVERS:
import servers
if app_config.DEPLOY_CRONTAB:
import cron_jobs
"""
Base configuration
"""
env.user = app_config.SERVER_USER
env.forward_agent = True
env.hosts = []
env.settings = None
from contextlib import contextmanager as _contextmanager
from fabric.context_managers import prefix
from fabric.operations import get, run, sudo
from fabric.state import env
from fabric.contrib import django
import boto3
django.project('dq')
from django.conf import settings
running_instances = []
s = boto3.session.Session(profile_name='dq')
ec2 = s.resource("ec2")
def get_ec2_instances():
instances = ec2.instances.filter(
Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
)
for i in instances:
ssh_access = "ubuntu@{0}".format(i.public_ip_address)
print 'servers >', ssh_access
running_instances.append(ssh_access)
get_ec2_instances()
environments = {
'production': {
'hosts': running_instances,
'source_code': '/home/ubuntu/www/dq.com/dq',
'supervisor_commands': [
'supervisorctl restart dq'
from fabric.api import local, task, prefix, run, sudo, env, require, cd, quiet
from fabric.colors import green, yellow
from fabric.contrib import django
from functools import wraps
import sys
import os.path
from getpass import getuser
from socket import gethostname
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('chopin')
from django.conf import settings
REPOSITORY = 'https://scm.cch.kcl.ac.uk/hg/chopin-django'
env.user = settings.FABRIC_USER
env.hosts = ['ocve3.dighum.kcl.ac.uk']
env.root_path = '/vol/ocve3/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
from fabric.api import run, local, hosts, cd
from fabric.contrib import django
django.project('viewcount')
def hello():
print("Hello Fabric")
def local_deploy():
local("./manage.py runserver")
# -*- coding: utf-8 -*-
import os.path
import sys
from functools import wraps
from django.conf import settings
from fabric.api import cd, env, prefix, quiet, require, run, sudo, task
from fabric.colors import green, yellow
from fabric.contrib import django
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('shakespeare400')
REPOSITORY = 'https://github.com/kingsdigitallab/shakespeare400-django.git'
env.user = settings.FABRIC_USER
env.hosts = ['s400.kdl.kcl.ac.uk']
env.root_path = '/vol/s400/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
env.servers.append(func)
'''
Created on Aug 19, 2014
@author: Kristian
'''
from fabric.api import *
from fabric.colors import green, red
from fabric.contrib import django
django.project('xavee')
from application import tasks
def prepare_test_fixtures():
print(green("Getting fixtures for testing from DB..."))
local(
"python manage.py makefixture --format=yaml --indent=4 application.IPhoneVersion[:1001] > application/fixtures/application.yaml"
)
def celery():
print(green("Starting Celery worker..."))
local("celery -A xavee worker -l info")
def redis():
print(green("Starting Redis server..."))
local("redis-server /usr/local/etc/redis.conf")
def runserver():
# Folder that contains settings/local.py
def find_project_name():
ret = None
for name in os.listdir(project_root):
if os.path.exists(os.path.join(
project_root, name, 'settings', 'local.py')):
if ret is not None:
raise Exception('Ambiguous project name')
ret = name
if not ret:
raise Exception('Could not find your Django project folder')
return ret
PROJECT_NAME = find_project_name()
django.project(PROJECT_NAME)
SERVER_NAME = getattr(django_settings, 'FABRIC_SERVER_NAME', PROJECT_NAME)
# Git repository pointer
REPOSITORY = 'https://github.com/kingsdigitallab/{}-django.git'.format(
PROJECT_NAME)
env.gateway = 'ssh.kdl.kcl.ac.uk'
# Host names used as deployment targets
env.hosts = ['{}.kdl.kcl.ac.uk'.format(SERVER_NAME)]
# Absolute filesystem path to project 'webroot'
env.root_path = '/vol/{}/webroot/'.format(SERVER_NAME)
# Absolute filesystem path to project Django root
env.django_root_path = '/vol/{}/webroot/'.format(SERVER_NAME)
# Absolute filesystem path to Python virtualenv for this project
# -*- coding: utf-8 -*-
import os.path
import sys
from functools import wraps
from django.conf import settings
from fabric.api import cd, env, prefix, quiet, require, run, sudo, task
from fabric.colors import green, yellow
from fabric.contrib import django
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('kdl')
REPOSITORY = 'https://github.com/kingsdigitallab/kdl-django.git'
env.user = settings.FABRIC_USER
env.hosts = ['kdl.kcl.ac.uk']
env.root_path = '/vol/kdl/webroot/'
env.gateway = 'ssh.cch.kcl.ac.uk'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
from fabric.api import lcd, sudo, local, cd, hosts
from fabric.colors import green, red, blue
from fabric.contrib import django
django.project('mhealth_web')
django.settings_module('mhealthcare.settings')
def test():
local("./manage.py test my_app")
def commit(local_branch_name="ridwan_current"):
local('git add -p && git commit')
local('git checkout master && git merge ' + local_branch_name)
def push(production_branch_name="ridwan_current"):
local("git push origin" + production_branch_name)
def prepare_deploy():
local_branch_name = raw_input("enter your local git branch name: ")
production_branch_name = raw_input(
"enter your production branch name to push to: ")
#test()
commit(local_branch_name)
push(production_branch_name)
def server_reboot():
REPOSITORY = 'https://github.com/kingsdigitallab/{}-django.git'.format(
PROJECT_NAME)
env.gateway = 'ssh.kdl.kcl.ac.uk'
# Host names used as deployment targets
env.hosts = ['{}.kdl.kcl.ac.uk'.format(PROJECT_NAME)]
# Absolute filesystem path to project 'webroot'
env.root_path = '/vol/{}/webroot/'.format(PROJECT_NAME)
# Absolute filesystem path to project Django root
env.django_root_path = '/vol/{}/webroot/'.format(PROJECT_NAME)
# Absolute filesystem path to Python virtualenv for this project
env.envs_path = os.path.join(env.root_path, 'envs')
# -------------------------------
django.project(PROJECT_NAME)
# Set FABRIC_GATEWAY = '[email protected]' in local.py
# if you are behind a proxy.
FABRIC_GATEWAY = getattr(django_settings, 'FABRIC_GATEWAY', None)
if FABRIC_GATEWAY:
env.forward_agent = True
env.gateway = FABRIC_GATEWAY
# Name of linux user who deploys on the remote server
env.user = django_settings.FABRIC_USER
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
from contextlib import contextmanager as _contextmanager
from fabric.context_managers import prefix
from fabric.operations import get, run, sudo
from fabric.state import env
from fabric.contrib import django
django.project('elbtest')
from django.conf import settings
environments = {
'production': {
'hosts': ['[email protected]:22',
'[email protected]:22'],
'source_code': '/home/ubuntu/www/elbtest',
'supervisor_commands': [
'supervisorctl restart elbtest',
],
'virtualenv': {
'virtualenv_name': 'elbtest',
'virtualenv_sh': '/usr/local/bin/virtualenvwrapper.sh',
},
'git': {
'parent': 'origin',
'branch': 'master',
}
}
}
# Utils
@_contextmanager
def virtualenv():
from contextlib import contextmanager
from fabric.context_managers import cd, path, shell_env, prefix, warn_only
from fabric.contrib import django
from fabric.contrib.files import (append, contains, sed, uncomment, exists,
upload_template)
from fabric.decorators import task
from fabric.operations import sudo, run, prompt, local
from fabric.state import env
from fabric.utils import abort
from pathlib import Path
django.project('dezede')
import django
django.setup()
from cachalot.api import invalidate as invalidate_cachalot
from django.conf import settings
GIT_REPOSITORY = 'https://github.com/dezede/dezede.git'
PROJECT_PATH = '/dezede/src'
RELATIVE_WORKON_HOME = '.virtualenvs'
VIRTUALENV_NAME = 'dezede'
DB_NAME = settings.DATABASES['default']['NAME']
DB_NAME_TEST = settings.DATABASES['default'].get('TEST_NAME',
'test_' + DB_NAME)
DB_USER = settings.DATABASES['default']['USER']
REDIS_SOCKET = '/var/run/redis/redis-server.sock'
REDIS_CONF = '/etc/redis/redis.conf'
REMOTE_BACKUP = '/dezede/backups/dezede.backup'
"""
Fabric File to deploy django project
"""
import logging
import os
from fabric.api import *
from fabric.colors import green, red
from fabric.contrib import django
from contextlib import contextmanager
django.project('jumpstart')
from profiles.models import Settings
# globals
LOGGER = logging.getLogger("fabric")
settings = Settings.objects.first()
user_home = os.path.expanduser('~')
path = user_home + "/" + str(settings.domain_path)
remote_user = settings.domain_user
remote_host = "%s@%s" % (remote_user,settings.domain_host)
def server():
env.hosts = [remote_host] # The Elastic IP to your server
env.user = remote_user # your user on that system
@contextmanager
def errorhandling():
import os.path
import sys
from functools import wraps
from getpass import getuser
from socket import gethostname
from django.conf import settings # noqa
from fabric.api import cd, env, local, prefix, quiet, require, run, sudo, task
from fabric.colors import green, yellow
from fabric.contrib import django
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('dprr')
REPOSITORY = '[email protected]:kingsdigitallab/dprr-django.git'
env.user = settings.FABRIC_USER
env.gateway = 'ssh.cch.kcl.ac.uk'
env.hosts = ['dprr.dighum.kcl.ac.uk']
env.root_path = '/vol/dprr/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
def notify_slack(message):
global SLACK_WEBHOOK, SLACK_ROOM
return requests.post(SLACK_WEBHOOK,
data=json.dumps({
'channel': SLACK_ROOM,
'username': '******',
'text': message,
'icon_emoji': ':squirrel:',
"unfurl_links": True
})).content
from fabric.contrib import django
django.project('webapp')
from widgets import models
def print_instances():
for instance in models.Widget.objects.all():
print("%s: %s" % (instance.id, instance))
def widgets():
with cd('~/webapps/fabric_demo/myproject'):
workon('fab print_instances')
def workon(command, **kwargs):
run("workon %s && %s" % ('fabric', command), **kwargs)
env.project_name)
env.ignored_coverage = (
'test',
'settings',
'migrations',
'fabfile',
'wsgi',
)
env.solr_conf_dir = '/etc/solr/conf'
env.db_user = '******'
env.db_name = 'comses_catalog'
env.vcs = 'git'
env.vcs_command = 'export GIT_WORK_TREE=%(deploy_dir)s && git checkout -f %(branch)s && git pull'
# django integration for access to settings, etc.
django.project(env.project_name)
from django.conf import settings as catalog_settings
@hosts('dev.commons.asu.edu')
@task
def docs(remote_path='/home/www/dev.commons.asu.edu/catalog/'):
with lcd(env.docs_path):
local("/usr/bin/make html")
rsync_project(local_dir='build/html/',
remote_dir=os.path.join(remote_path, 'apidocs'),
delete=True)
execute(coverage)
rsync_project(local_dir='htmlcov/',
remote_dir=os.path.join(remote_path, 'coverage'),
delete=True)
def local_clear_database():
"""Recreate schema"""
django.project(env.django_project)
from django.conf import settings
env.role = settings.DATABASES['default']['USER']
local('echo "DROP SCHEMA public CASCADE;CREATE SCHEMA public AUTHORIZATION %(role)s;GRANT ALL ON SCHEMA public TO %(role)s;" | bin/django dbshell' % env)
from fabric.api import env, task, get, lcd, local
from fabric.contrib import django
import sys
import os.path
sys.path.insert(0, os.path.dirname(env.real_fabfile))
django.project('pycon')
from django.conf import settings
env.use_ssh_config = True
env.hosts = [ 'pycon.it' ]
@task
def sync_db():
remote_path = '/srv/europython/data/site/p3.db'
local_path = settings.DATABASES['default']['NAME']
get(remote_path, local_path)
def parent_(path):
if path[-1] == '/':
path = path[:-1]
return os.path.dirname(path)
@task
def sync_media():
remote_path = '/srv/europython/data/media_public'
local_path = parent_(settings.MEDIA_ROOT)
get(remote_path, local_path)
@task
import os
import subprocess
from random import Random
from fabric.api import local, cd, run, env, lcd, sudo, prefix
from fabric.contrib import django
django.project('apps')
from django.conf import settings
# Variable setup
env.project_root = settings.PROJECT_ROOT
env.project_name = settings.PROJECT_NAME
env.path = "/home/journal/%(project_name)s" % env
env.django_root = os.path.join(env.project_root, 'apps/')
env.hosts = ['*****@*****.**']
env.media = env.path + '/media/'
local_dumps = os.path.join(env.project_root, 'dumps/')
env.pip_requirements = "requirements.txt"
# helper functions
def generate_random():
rng = Random()
r_seed = "1234567890qwertyuiopasdfghjklzxcvbnm"
env.secret_key = ""
for i in range(30):
def populate_demo(name):
django.project('get2')
from get2.persone.models import Persona
for i in Persona.objects.all():
print(i)
from fabric.contrib import django as ddd
import django
ddd.project("project")
django.setup()
import getpass
import os
import time
from django.contrib.auth.models import User
from django.utils import timezone
from fabric.api import env, require, run, sudo, cd, local, get
from project.fabfile_secret import *
from videoclases.models import *
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
file_name = 'videoclases/project/settings_secret.py'
template_name = 'videoclases/project/settings_secret.py.template'
def _load_data(reboot=False):
local('python manage.py makemigrations')
local('python manage.py migrate')
if reboot:
fixtures = ['devgroups', 'devusers', 'devcolegio', 'devcursos', 'devalumnos', 'devprofesores',
'devtareas']
for f in fixtures:
local('python manage.py loaddata ' + f)
# fab devserver -> states that you will connect to devserver server
def devserver():
@author: john
'''
import imp
from fabric import api as fab
from fabric import colors
from fabric.contrib.console import confirm
from fabric.contrib import django as fab_django
from .. import amazon
from ..utils import log_to_file
from . import (apache, nginx, celery, svn, django, puppet, memcached, uwsgi, git)
fab_django.settings_module('project.settings')
fab_django.project('project')
fab.env.user = '******'
fab.env.key_filename = '~/.ssh/key.pem'
@fab.task(alias='command')
def run_command(command, cd="/", use_sudo=True):
"""
Runs an arbitrary command on the servers
PARAMS:
command - The command to run on the servers
cd - The path on which to run the command (defaults to "/")
use_sudo - Boolean specifying if you want to use sudo when running the command (Defaults to True)
"""
print(colors.green("Running command {command} on server {host}".format(host=fab.env.host, command=command)))
import os
import subprocess
from random import Random
from fabric.api import local, cd, run, env, lcd, sudo, prefix
from fabric.contrib import django
django.project('apps')
from django.conf import settings
# Variable setup
env.project_root = settings.PROJECT_ROOT
env.project_name = settings.PROJECT_NAME
env.path = "/home/journal/%(project_name)s" % env
env.django_root = os.path.join(env.project_root, 'apps/')
env.hosts = ['*****@*****.**']
env.media = env.path + '/media/'
local_dumps = os.path.join(env.project_root, 'dumps/')
env.pip_requirements = "requirements.txt"
# helper functions
def generate_random():
rng = Random()
r_seed = "1234567890qwertyuiopasdfghjklzxcvbnm"
env.secret_key = ""
for i in range(30):
env.secret_key += rng.choice(r_seed)
from fabric.api import local, task, prefix, run, sudo, env, require, cd, quiet
from fabric.colors import green, yellow
from fabric.contrib import django
from functools import wraps
import sys
import os.path
from getpass import getuser
from socket import gethostname
# put project directory in path
project_root = os.path.abspath(os.path.dirname(__file__))
sys.path.append(project_root)
django.project('tvof')
from django.conf import settings
REPOSITORY = ''
env.user = settings.FABRIC_USER
env.hosts = ['']
env.root_path = '/vol/tvof/webroot/'
env.envs_path = os.path.join(env.root_path, 'envs')
def server(func):
"""Wraps functions that set environment variables for servers"""
@wraps(func)
def decorated(*args, **kwargs):
try:
from fabric.api import env, prompt, get, local, run, hosts, cd
from fabric.contrib import django
django.project("scoutfile3") # noqa
from django.conf import settings
from fabric.contrib import files
import os
import datetime
# this is needed here to evaluate settings here, and not in the fabric task
# workaround for this bug: https://github.com/fabric/fabric/issues/256
_ = settings.INSTALLED_APPS
@hosts('yeti.albascout.ro:24')
def seed_db():
# based on a script from http://www.iangeorge.net/articles/2010/jul/22/getting-live-data-mysqldump-and-fabric/
data = (settings.DATABASES['default']['NAME'], settings.REMOTE_DB['host'],
settings.REMOTE_DB['name'])
env.hosts = [
settings.REMOTE_DB["ssh_host"],
]
env.user = settings.REMOTE_DB["ssh_user"]
msg = prompt("Sure you want to get '%s' from '%s>%s'?" % data,
default="y/n")
if msg == "y":
run('mysqldump --user %s --password=%s %s | gzip > /tmp/%s.sql.gz' %
(settings.REMOTE_DB['user'], settings.REMOTE_DB['password'],
from fabric.api import local, settings, env, lcd, cd
from datetime import date, datetime, timedelta
import os
from fabric.contrib import django
import json
django.project('habakkuk')
from web.models import ClusterData
from web.cluster_topics import find_topics
import logging
from django.utils.timezone import now
logger = logging.getLogger(__name__)
def config():
# TODO: add fabricrc
vars = {
'hk.data':env.get('hk.data','/opt/habakkuk_data/'),
'hk.input':env.get('hk.input','input'),
'hk.vectors':env.get('hk.vectors','vectors'),
'hk.named_vectors':env.get('hk.named_vectors','vectors-nv'),
'hk.pig_script':env.get('hk.pig_script', 'verse_vectors.pig'),
'hk.pig.join_data':env.get('hk.pig.join_data','join_data'),
'hk.mahout.num_clusters':env.get('hk.mahout.num_clusters','10'),
'hk.mahout.num_iterations':env.get('hk.mahout.num_iterations','5'),
'hk.mahout.output':env.get('hk.mahout.output','clusters'),
'hk.mahout.metric':env.get('hk.mahout.metric','org.apache.mahout.common.distance.CosineDistanceMeasure'),
'hk.mahout.converge':env.get('hk.mahout.converge','0.1'),
'hk.mahout.dump.terms':env.get('hk.mahout.dump.terms','10'),
'hk.mahout.dump.json':env.get('hk.mahout.dump.json','/tmp/clusterdump.json'),
'hk.mahout.dump.text':env.get('hk.mahout.dump.text','/tmp/clusterdump.txt'),
'hk.mahout.dictionary':env.get('hk.mahout.dictionary','./join_data/verse.dictionary'),
}
import os
from fabric.contrib import django
django.project('ivelum')
from fabric.api import local, task
from fabric.decorators import runs_once
from api.v1.models import Worker, Status, Task
from django.contrib.auth.models import User
BASE_DIR = os.path.sep.join((os.path.dirname(__file__), ''))
@task
@runs_once
def runserver():
"""
Runs the local Django server
"""
local('open "http://127.0.0.1:8000" && python ./manage.py runserver')
@task
@runs_once
def delpyc():
"""
Runs the local Django server
"""
local('find . -name "*.pyc" -delete')
# encoding: utf-8
from fabric.api import *
from fabric.contrib import django
from fabric.colors import green, red
__all__ = ('deploy', 'deploy_fast', 'rsync', 'dirty_deploy', 'dirty_fast', 'shell', 'ssh',
'restart', 'manage', 'install_requirements', 'migrate',
'pull_db')
django.project('stargeo')
env.cwd = '/home/ubuntu/app'
env.use_ssh_config = True
env.hosts = ['stargeo']
activate = lambda: prefix('source ~/venv/bin/activate')
def restart():
print(green('Restarting celery...'))
sudo('supervisorctl restart celery')
print(green('Reloading uWSGI...'))
run('touch uwsgi-reload')
def collect_static():
execute(manage, 'collectstatic --noinput')
def migrate():
from fabric.api import *
from fabric.contrib import django
django.project('rdademo')
from rdademo.rda.models import *
def production():
env.hosts = ['a29.myrootshell.com']
env.user = '******'
env.app_details = { 'name': 'RDA Demo', \
'version': '0.1'}
env.deploy_to = '/tmp/rdademo'
env.repository = {'url':'svn+ssh://a29.myrootshell.com/var/svn/rdademo/trunk', \
'username': '******', \
'password': '******' \
'command': 'svn export --force'}
set(fab_user='******',
root='/var/django/rdademo/',
site='rda',
backup_name = 'prod_db.sql')
def export_repository():
""" Export svn repository """
run('%s --username %s --password %s --no-auth-cache %s %s' % \
(env.repository['command'], env.repository['username'], env.repository['password'], env.repository['url'], env.deploy_to)
run('tar -C env.deploy_to -czvf rdademo.tar.gz')
def dump_production_database():
""" Dump the postgres database """
run('pg_dump -U %s -W %s %s > /tmp/$(backup_name) | gzip > prod_db.sql.tar.gz' % (
