Fabric demo for deploying java web application

fabric demo

#coding=utf-8
__author__ = 'brody'

"""
auto deploying java web application
command examples:
fab deploy_live
fab rollback_beta
run 'fab -l' for more
"""

from os.path import exists as lexists
from fabric.api import env, run, cd, sudo, task, lcd, local, execute, put, roles
from fabric.contrib.files import exists as rexists, contains
from fabric.contrib.project import upload_project

env.roledefs = {
    'beta': ['youraccount@192.168.1.2'],
    'live': ['youraccount@192.168.1.3', 'youraccount@192.168.1.4'],
}
code_base = '/data/project/'
project_name = 'your-project-name'
code_home = code_base + project_name + '/'
remote_project_dir = '/data/project/' + project_name + '/'
remote_tomcat_shell = remote_project_dir + '/tomcat.sh'
remote_project_dir_bak = '/data/project/' + project_name + '_bak/'
remote_log_dir = '/data/log/' + project_name + '/'
remote_tomcat_tmp_dir = '/tmp/' + project_name + '/'
owner = 'your-project-owner-account'
global config_source_base, remote_config_dir

def set_remote_config():
    """
    init base folders and app user in server
    """
    global remote_config_dir
    remote_config_dir = '/data/config/' + project_name
    global remote_config_dir_bak
    remote_config_dir_bak = remote_config_dir + '_bak'
    if not contains('/etc/passwd', owner, use_sudo=True):
        sudo('useradd -m -s "/bin/bash" %s' % (owner))

def check_remote_dirs():
    """
    check the project folders in server.
    if not, create it
    depend on set_remote_config() method
    """
    check_remote_dir(remote_project_dir, owner)
    check_remote_dir(remote_log_dir, owner)
    check_remote_dir(remote_config_dir, owner)
    check_remote_dir(remote_tomcat_tmp_dir, owner)

def check_remote_dir(dir, owner):
    """
    check remote folder.
    if not, create it
    """
    if(not rexists(dir)):
        sudo(('mkdir -pv %s;chown -R %s:%s %s' % (dir, owner, owner, dir)))

def sync_code():
    """
    get latest source codes and deploy to remote host
    depend on check_remote_dir() method
    """
    if(not lexists(code_home + 'target/' + project_name + '.war')):
        raise Exception("classes or lib folder is not exist.")
    with lcd(code_home):
        put('target/' + project_name + '.war', remote_project_dir, use_sudo=True)
    put('tomcat.sh', remote_project_dir, mode=0700, use_sudo=True)
    put(config_source_base + '/*', remote_config_dir, mode=0400, use_sudo=True)
    with cd(remote_project_dir):
        sudo('unzip ' + project_name + '.war -d LIVE; rm -f ' + project_name + '.war')
    sudo(('chown -R %s:%s %s; chown -R %s:%s %s' % (owner, owner, remote_project_dir, owner, owner, remote_config_dir)))


def backup():
    """
    backup source folders.
    depend on check_remote_dir() method
    """
    if(rexists(remote_project_dir)):
        sudo('rm -rf ' + remote_project_dir_bak)
        sudo("mv -f %s %s" % (remote_project_dir, remote_project_dir_bak))
        sudo(('mkdir -pv %s; chown -R %s:%s %s' % (remote_project_dir, owner, owner, remote_project_dir)))
    if(rexists(remote_config_dir)):
        sudo('rm -rf ' + remote_config_dir_bak)
        sudo("mv -f %s %s" % (remote_config_dir, remote_config_dir_bak))
        sudo(('mkdir -pv %s; chown -R %s:%s %s' % (remote_config_dir, owner, owner, remote_config_dir)))


def stop_app():
    if(rexists(remote_tomcat_shell)):
        sudo('%s stop' % (remote_tomcat_shell), user=owner)


def start_app():
    sudo('%s start' % (remote_tomcat_shell), user=owner)


def deploy():
    """
    deploy the project to servers
    """
    execute(set_remote_config)
    execute(stop_app)
    execute(check_remote_dirs)
    execute(backup)
    execute(sync_code)
    execute(start_app)


def rollback():
    """
    rollback the project in servers
    """
    execute(set_remote_config)
    if(not rexists(remote_project_dir)):
        raise Exception(("The project folder(%s) is not exist in host %s." % (remote_project_dir, env.host)))
    execute(check_remote_dirs)
    if(rexists(remote_project_dir_bak) and rexists(remote_config_dir_bak)):
        execute(stop_app)
        sudo('rm -rf ' + remote_project_dir)
        sudo("mv -f %s %s" % (remote_project_dir_bak, remote_project_dir))
        sudo('rm -rf ' + remote_config_dir)
        sudo("mv -f %s %s" % (remote_config_dir_bak, remote_config_dir))
        execute(start_app)
    else:
        raise Exception((
        "The backup folder(%s or %s) is not exist in host %s." % (remote_project_dir_bak, remote_config_dir_bak, env.host)))


@task
@roles('live')
def deploy_live():
    """
    deploy latest to yoursite.com
    """
    global config_source_base
    config_source_base = 'live'
    deploy()

@task
@roles('live')
def rollback_live():
    """
    rollback in yoursite.com
    """
    rollback()

@task
@roles('beta')
def deploy_beta():
    """
    deploy latest to beta-yoursite.com
    """
    global config_source_base
    config_source_base = 'beta'
    deploy()

@task
@roles('beta')
def rollback_beta():
    """
    rollback in beta-yoursite.com
    """
    rollback()

Thanks