functions

#!/bin/sh

set +o noclobber # Why yes, I did mean to clobber that file.

hook()
{
  trace_filter "deploy" || set -o xtrace

  local _hook
  _hook="$1"

  (( _hooks_flag )) || return 0

  # System; Shared
  if path exists "${shared_path}/deploy"
  then
    if path exists "${shared_path}/deploy" &&
      file is executable "${shared_path}/deploy/$_hook"
    then
      log step "${_hook} ( ${shared_path##${project_path}/}/deploy/ )"
      hook_source "${shared_path}/deploy/$_hook" &> >(tee -a "${deploy_log_path}/${_hook}.log")

      log step success
    fi
  fi

  # System; Shared, Environment
  if variable is nonempty environment &&
    file is executable "$shared_path/deploy/${environment}/${_hook}"
  then
    log step "${_hook} ( ${shared_path##${project_path}/}/deploy/${environment}/ )"
    hook_source "$shared_path/deploy/${environment}/${_hook}" &> >(tee -a "${deploy_log_path}/${_hook}.log")
    log step success
  fi

  # Project; Repository
  if path exists "$shared_path/$project" &&
    file is executable "$shared_path/$project/config/deploy/${_hook}"
  then
    log step "${_hook} ( ${shared_path##${project_path}/}/${project}/config/deploy/ )"
    hook_source "$shared_path/$project/config/deploy/${_hook}" &> >(tee -a "${deploy_log_path}/${_hook}.log")
    log step success
  fi

  # Project; Repository, Environment
  if variable is nonempty environment &&
    file is executable "$shared_path/$project/config/deploy/$environment/${_hook}"
  then
    log step "${_hook} ( ${shared_path##${project_path}/}/${project}/config/deploy/${environment}/ )"
    hook_source "$shared_path/$project/config/deploy/$environment/${_hook}" &> >(tee -a "${deploy_log_path}/${_hook}.log")
    log step success
  fi
}

hook_source()
{
  trace_filter "deploy" || set -o xtrace
  ( set -v ; source "$1" )
}

before_step()
{
  trace_filter "deploy" || set -o xtrace
  hook "before_$1" "$@"
}

after_step()
{
  trace_filter "deploy" || set -o xtrace
  hook "after_$1" "$@"
}

update()
{
  trace_filter "deploy" || set -o xtrace

  update_repository && release
}

update_repository()
{
  trace_filter "deploy" || set -o xtrace

  log step "update_repository ( ${shared_path##${project_path}/}/${project} )"
  fetch_uri "$repository_url" "$shared_path/$project" "${branch:-}"
  log step success

  path enter "${shared_path}/${project}"

  log " TODO: **** move revision handling to fetch_uri ****"

  case "${scm_type}" in
    (git|github)
      if files exists ".gitmodules"
      then
        log step "Updating submodules"
        git submodule init > "${deploy_log_path}/git-submodules.log" 2>&1
        git submodule update >> "${deploy_log_path}/git-submodules.log" 2>&1
        log step success
      fi

      if variable is nonempty revision
      then
        log step "Checking out revision '$revision'."
        git checkout $revision > "${deploy_log_path}/git-checkout.log" 2>&1
        log step success
      else
        revision=$( git log --no-color -1 | awk '/commit/{print $2}')
        revision=${revision:0:7}
      fi

      if variable is nonempty branch
      then
        branch=$( git branch --no-color | awk '/^\* /{print $2}')
      fi
      ;;
    (hg)
      if variable is nonempty revision
      then
        # TODO: Find out if this is how it's done for hg ;)
        log step "Checking out revision '$revision'."
        hg update $branch $revision  > "${deploy_log_path}/hg-update.log" 2>&1
        log step success
      else
        log step "Updating branch '$branch'."
        hg update $branch > "${deploy_log_path}/hg-update.log" 2>&1
        log step success
      fi
      ;;
    (svn)
      if variable is nonempty revision && (( revision > 0 ))
      then
        log step "Checking out revision $revision"
        svn checkout -r $revision > "${deploy_log_path}/svn-checkout.log" 2>&1
        log step success
      fi
      ;;
  esac
}

stage()
{
  trace_filter "deploy" || set -o xtrace

  log step "stage ~ staging ${project} ${branch:-} ${revision:-} ( ${stage_path##${project_path}/} )"
  rsync -avg --delete --exclude=".${scm_type}/" "${shared_path}/${project}/" "${stage_path}/" \
    > "${deploy_log_path}/stage-rsync.log" 2>&1
  log step success

  path enter "$stage_path"
  path create "$stage_path/public"
}

fail_stage()
{
  trace_filter "deploy" || set -o xtrace

  if path exists "${stage_path}"
  then
    log step "stage fail ~ Removing staged release ( $stage_path )" \
      path move from "${stage_path}" to "${discard_path}/${timestamp}"
  fi
}

release()
{
  trace_filter "deploy" || set -o xtrace

  typeset _prefix
  _prefix="${shared_path%/*}"

  #TODO: version detection failed !!!

  versionedfs add \
    path "${project_path}" \
    name "${project}" \
    version ${version:=$(date +"%Y-%m-%dT%H:%M:%S")} \
    source "$stage_path"

  versionedfs activate \
    path "${project_path}" \
    name "${project}" \
    version ${version:=$(date +"%Y-%m-%dT%H:%M:%S")}

  path remove "$stage_path"

  path enter "$release_path"
}

configure()
{
  trace_filter "deploy" || set -o xtrace

  local _name _file _path _paths _prefix _shared_public_path

  _prefix="${shared_path%/*}"
  _shared_public_path="${shared_path}/public"

  if ! path exists "${shared_path}/config"
  then
    return 0
  fi

  path enter "${shared_path}/config"

  for _file in "${shared_path}"/config/*
  do
    _name="${_file##*/}"

    log step "  link ~ ${_name} ( ${shared_path##${project_path}/}/config/${_name} => $stage_path/config/${_name} )"

    path remove "$stage_path/config/${_name}"

    file link symbolic \
      from "$shared_path/config/${_name}" \
      to "$stage_path/config/${_name}"

    log step success
  done

  if path exists "$shared_path/db"
  then
    log step "  link ~ db path ( ${shared_path##${project_path}/}/db => ${stage_path##${project_path}/}/db )"
    path remove "$stage_path/db"
    file link symbolic from "$shared_path/db" to "$stage_path/db"
    log step success
  fi

  for _path in tmp log pids #files
  do
    if path exists "${stage_path}/${_path}"
    then
      path remove "${stage_path}/${_path}"
    fi
    log step "  link ~ ${_path} ( ${shared_path##${project_path}/}/${_path} => ${stage_path##${project_path}/}/${_path} )"

    path remove "${stage_path}/${_path}"
    file link symbolic \
      from "${shared_path}/${_path}" \
      to "${stage_path}/${_path}"
    log step success
  done

  if ! path exists "$shared_path/public/"
  then
    log error "\nPlease run the folloing command first and then retry:\n\tsm rails setup"
  fi

  _paths=($( find "${shared_path}/public" -mindepth 1 -maxdepth 1 -type d ))

  for _path in "${_paths[@]}"
  do
    _path="${_path#${_shared_public_path}/}"

    log step "  link ~ public ${_path} ( ${shared_path##${project_path}/}/public/${_path} => ${stage_path##${project_path}/}/public/${_path} )"

    path remove "${stage_path}/public/${_path}"
    file link symbolic \
      from "${_shared_public_path}/${_path}" \
      to "${stage_path}/public/${_path}"

    log step success
  done
}

record()
{ # TODO: What else could we record that would be useful?
  trace_filter "deploy" || set -o xtrace

  paths exist "${release_path}" || return 0 # Release failed, nothing to do...

  if variable is nonempty revision
  then
    file write string "${revision}" to "${release_path}/revision"
  fi

  if variable is nonempty branch
  then
    file write string "${branch}" to "${release_path}/branch"
  fi

  if variable is nonempty repository_url # TODO: get this from the .uri file.
  then
    file write string "$repository_url" to "${release_path}/repository_url"
  fi

  if variable is nonempty timestamp
  then
    files write string "${timestamp}" to "${release_path}/timestamp"
  fi
}

remove_releases()
{
  trace_filter "deploy" || set -o xtrace

  local _release

  path enter "${versions_path}"

  while (( $# > 0 ))
  do
    _release="${1#*:}"
    shift
    log "Removing old release ${_release}"
    versionedfs remove \
      path "${project_path}" \
      name "${project}" \
      version ${_release}
  done
}

cleanup()
{
  trace_filter "deploy" || set -o xtrace

  if array is empty old_releases || ! path exists "${versions_path}"
  then
    return 0 # No old releases
  fi

  if ! remove_releases "${old_releases[@]}"
  then
    log warn "There was an error removing old releases (${old_releases[*]})."
  fi
}

do_deploy()
{
  trace_filter "deploy" || set -o xtrace

  PATH="./bin:$PATH" # Account for project-specific command overrides.

  # Logging (http://nakedape.cc/wiki/ShellHacks 1.6.1, 1.7, 1.11)
  log_file="${deploy_log_path}/deploy.log"
  touch "${log_file}"
  #exec 3>>"${log_file}"
  exec > >(tee -a "${log_file}") 2>&1
  # Error handling
  trap revert_on_error ERR
  trap revert_on_error ZERR

  # This will run any deploy hooks that are called
  #   (by hook file name)
  # Hooks are sourced into a subshell IF they are executable.
  # This means that users may disable hooks by changing their
  # execute bit.
  #
  if ! command exists rsync
  then
    error "The 'rsync' command was not found, please install rsync before using deploy."\
      "(Note that there is an rsync extension in the networking extension set)\n"\
      "root# sm sets install networking ; sm rsync package install"
  fi

  if path exists "${release_path}"
  then # If release path already exists, start inside it.
    path enter "$release_path"
  fi

  log "  Deploy started at ${timestamp}"
  step deploy
  log "  Deploy completed at $(date +%m.%d.%YT%H:%M:%S)"
}

deploy()
{
  trace_filter "deploy" || set -o xtrace

  typeset _step
  for _step in "${deploy_steps[@]}"
  do
    step "${_step}" &> >(tee -a "${log_file}")
  done
}

revert_on_error()
{
  trace_filter "deploy" || set -o xtrace

  result=$?
  trap "backtrace \"An errorr occured while reverting.\"" ERR
  trap "backtrace \"An errorr occured while reverting.\"" ZERR
  backtrace "A command has returned an not handled error code (${result})." no_exit 2>"${log_file}"
  log "\nAn error occured, reverting...\n  for details check the logfiles in ${deploy_log_path}/\n" >&2
  retreat >&2
  kill -s USR2 $APP_PID #to exit application not current subshell
}

revert()
{
  retreat
}

do_revert()
{
  trace_filter "deploy" || set -o xtrace

  log "  Reverting ..."
  retreat "deploy" "${deploy_steps[@]}"
}

fail_release()
{
  trace_filter "deploy" || set -o xtrace

  if path exists "$stage_path"
  then
    log step "discard ~ Discarding stage ( $discard_path/$timestamp )"
    path move from "$stage_path" to "$discard_path/$timestamp"
    log step success
  fi

  if variable is nonempty initial_release
  then
    paths exist "$initial_release" || return 0
  else
    return 0
  fi

  paths create "$discard_path" "$deploy_log_path"

  # TODO: versionedfs last # switch to last version
  log step "Reverting to previous release $previous"
  path move from "$previous" to "${release_path%/}"
  log step success
}