build and deploy project(s)

_config.sh.example

prefix=/home/wakame

git_repo_maps="
 wakame-adapters=git://github.com/axsh/wakame-adapters.git
 wakame-vdc=git://github.com/axsh/wakame-vdc.git
"
initscript=./initializer/initscript.sh

environment=development
#environment=integration
#environment=production

#work_dir=${abs_path}/tmp
#helper_dir=${work_dir}/00_helper
#bundle_dir=${work_dir}/01_bundle
#build_dir=${work_dir}/02_build
#predeploy_dir=${work_dir}/03_predeploy
#deploy_dir=${work_dir}/04_deploy
#manifest_dir=${abs_path}/manifest

deployment_nodes="
 127.0.0.1
"

buildep.sh

#!/bin/bash
#
# Masahito Yoshida <masahito@axsh.net>
#
set -e

LANG=C
LC_ALL=C

#
abs_path=$(cd $(dirname $0) && pwd)
#
work_dir=${work_dir:-${abs_path}/tmp}
helper_dir=${helper_dir:-${work_dir}/00_helper}
bundle_dir=${bundle_dir:-${work_dir}/01_bundle}
build_dir=${build_dir:-${work_dir}/02_build}
predeploy_dir=${predeploy_dir:-${work_dir}/03_predeploy}
deploy_dir=${deploy_dir:-${work_dir}/04_deploy}
manifest_dir=${manifest_dir:-${abs_path}/manifest}
#
environment=${environment:-development_1box}
prefix=${prefix:-/home/wakame}
initscript=${initscript:-}
#
[ -f ${abs_path}/_config.sh ] && . ${abs_path}/_config.sh

#
cleanup_dirs="
 ${work_dir}
 ${bundle_dir}
 ${build_dir}
 ${predeploy_dir}
 ${deploy_dir}
"

function shlog() {
  echo "\$ $*" "(cwd: `pwd`)"
  eval $*
}

function task_prepare_helper() {
  [ -d ${helper_dir} ] || shlog git clone git://gist.github.com/1382117.git ${helper_dir}
}

function task_bundle_local_gem() {
  task_prepare_helper
  cd ${helper_dir}

  [ -d ${bundle_dir} ] || mkdir -p ${bundle_dir}

  for git_repo_map in ${git_repo_maps}; do
    target=${git_repo_map%%=*}
    git_uri=${git_repo_map##*=}

    _tmp_prefix=/var/tmp/__$(basename $0)
    # before_clean
    [ -d ${_tmp_prefix} ] && rm -rf ${_tmp_prefix}

    # bundle-local-gem.sh will pull/checkout the git-repo.
    [ -f ${target}.tar.gz ] || shlog tmp_prefix=${_tmp_prefix} ${helper_dir}/bundle-local-gem.sh ${target}=${git_uri}
    #shlog rsync -avx ${target}.tar.gz ${bundle_dir}/
    shlog mv ${target}.tar.gz ${bundle_dir}/

    # after_clean
    [ -d ${_tmp_prefix} ] && rm -rf ${_tmp_prefix}
  done

}

function task_build_bundled() {
  task_prepare_helper

  [ -d ${build_dir}  ] || mkdir -p ${build_dir}
  cd ${build_dir}
  for git_repo_map in ${git_repo_maps}; do
    target=${git_repo_map%%=*}
    git_uri=${git_repo_map##*=}

    [ -f ${bundle_dir}/${target}.tar.gz ] || {
      echo "no such file: ${bundle_dir}/${target}.tar.gz" >&2
      exit 1
    }
    shlog ${helper_dir}/build-bundled-tarball.sh ${bundle_dir}/${target}.tar.gz
  done
}

function task_predeploy() {
  [ -d ${predeploy_dir} ] && shlog rm -rf ${predeploy_dir}
  shlog mkdir -p ${predeploy_dir}

  for git_repo_map in ${git_repo_maps}; do
    target=${git_repo_map%%=*}
    git_uri=${git_repo_map##*=}

    [ -d ${build_dir}/${target} ] || {
      echo "no such directory: ${build_dir}/${target}" >&2
      exit 1
    }
    echo "... ${target}"

    shlog rsync -ax --exclude=".git*" ${build_dir}/${target} ${predeploy_dir}/
  done
  echo "=> ${predeploy_dir}/"
}

function task_deploy_config() {
  [ -d ${manifest_dir} ] || return 0

  echo ...common
  [ -d ${manifest_dir}/common/ ] && \
   shlog rsync -avx ${manifest_dir}/common/ ${predeploy_dir}/
  echo environment=${environment}
  [ -d ${manifest_dir}/${environment}/ ] && \
   shlog rsync -avx ${manifest_dir}/${environment}/ ${predeploy_dir}/
}

function task_prepare_deployment() {
  [ -d ${predeploy_dir} ] || {
    task_predeploy
    task_deploy_config
  }

  cd ${predeploy_dir}
  [ -d ${deploy_dir} ] || mkdir -p ${deploy_dir}

  for git_repo_map in ${git_repo_maps}; do

    target=${git_repo_map%%=*}
    git_uri=${git_repo_map##*=}

    [ -d ${predeploy_dir}/${target} ] || {
      echo "no such directory: ${predeploy_dir}/${target}" >&2
      exit 1
    }
    echo "... ${target}"
    shlog tar zcf ${deploy_dir}/${target}.tar.gz ${target}/
  done
}

function deploy_local() {
  shlog rsync -avx --exclude=".git*" ${predeploy_dir}/ ${prefix}/
}

function deploy_remote() {
  deployment_node=$1
  echo "${predeploy_dir}/ => ${deployment_node}:${prefix}/"
  #rsync -avx --exclude=".git*" ${predeploy_dir}/ ${deployment_node}:${prefix}/

  for git_repo_map in ${git_repo_maps}; do
    target=${git_repo_map%%=*}
    git_uri=${git_repo_map##*=}

    echo ... ${target}
    shlog rsync -ax ${deploy_dir}/${target}.tar.gz ${deployment_node}:/var/tmp/
    shlog ssh ${deployment_node} "\"cd ${prefix} && tar zxf /var/tmp/${target}.tar.gz && rm -f /var/tmp/${target}.tar.gz\""
  done
}

while test $# -gt 0
do
echo "[$1]"

[ -d ${work_dir} ] || mkdir -p ${work_dir}

case "$1" in
build:p0)
  task_prepare_helper
  ;;
build:p1)
  task_bundle_local_gem
  ;;
build:p2)
  task_build_bundled
  ;;
build:p3)
  task_predeploy
  ;;
build:p4)
  task_deploy_config
  ;;
build:p5)
  task_prepare_deployment
  ;;
build)
  $0 build:p1 build:p2 build:p3 build:p4 build:p5
  ;;

closed:prepare)
  $0 build:p1
  ;;
closed:build)
  $0 build:p2 build:p3 build:p4 build:p5
  ;;
closed:help)
  echo "node-1: ip reaclable"
  echo "node-2: ip unreachable"
  echo
  echo "* should run on node-1"
  echo "  node-1\$ $0 closed:prepare"
  echo
  echo "* should sync ${bundle_dir} via step node(s)"
  echo "  node-1 -> (step node) -> node-2"
  echo
  echo "* should run on node-2"
  echo "  node-2\$ $0 closed:build"
  echo
  echo "* should run on node-2"
  echo "  node-2\$ $0 deploy"
  echo "  node-2\$ $0 init"
  ;;

deploy)
  $0 deploy:remote
  ;;

deploy:local)
  deploy_local
  ;;

deploy:remote)
  for deployment_node in ${deployment_nodes}; do
    case ${deployment_node} in
    localhost|127.0.0.1)
      deploy_local
      ;;
    *)
      deploy_remote ${deployment_node}
      ;;
    esac
  done
  ;;

init)
  [ -x ${initscript} ] && ${initscript}
  ;;

pack:me)
  cd ..
  shlog tar zcvf $(basename ${abs_path}).tar.gz $(basename ${abs_path}/) \
   --exclude _config.sh \
   --exclude .git \
   --exclude tmp $(
    for git_repo_map in ${git_repo_maps}; do
      target=${git_repo_map%%=*}
      git_uri=${git_repo_map##*=}

      echo --exclude "${target}.tar.gz"
    done
   )
  cd -
  ;;

clean)
  for cleanup_dir in ${cleanup_dirs}; do
    [ -d ${cleanup_dir} ] && rm -rf ${cleanup_dir}
  done
  ;;
*)
  echo no such task: $1 >&2
  exit 1
  ;;
esac

shift
done