slugforge 4.0.0

data/lib/slugforge/models/logger.rb

@@ -0,0 +1,36 @@
+module Slugforge
+  class Logger
+    def initialize(thor_shell, log_level = :info)
+      @thor_shell = thor_shell
+      @log_level  = log_level
+    end
+
+    def log(message="", opts={})
+      return if @log_level != :verbose && opts[:log_level] == :verbose
+      if opts[:status]
+        say_status opts[:status], message, opts[:color]
+      else
+        if opts[:force_new_line]
+          say message, opts[:color], true
+        else
+          say message, opts[:color]
+        end
+      end
+    end
+
+    def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)\z/))
+      return if [:quiet, :json].include?(@log_level)
+      @thor_shell.say message, color, force_new_line
+    end
+
+    def say_status(status, message, log_status=true)
+      return if [:quiet, :json].include?(@log_level)
+      @thor_shell.say_status status, message, log_status
+    end
+
+    def say_json(message)
+      return unless @log_level == :json
+      @thor_shell.say message.to_json
+    end
+  end
+end

data/lib/slugforge/models/tag_manager.rb

@@ -0,0 +1,125 @@
+module Slugforge
+  class TagManager
+    def initialize(opts)
+      bucket(opts)
+    end
+
+    def bucket(opts={})
+      if @bucket.nil? || (true == (opts[:refresh] || @bucket_dirty))
+        @s3 = opts[:s3] || @s3
+        @aws_bucket = opts[:bucket] || @aws_bucket
+        @bucket = @s3.directories.get(@aws_bucket)
+        @slugs_for_tag = {}
+        @tags = {}
+        @bucket_dirty = false
+      end
+      @bucket
+    end
+
+    def projects
+      return [] if bucket.files.nil?
+      result = {}
+      bucket.files.each do |file|
+        result[$~[1]] = true if (file.key =~ /^([^\/]+)\//)
+      end
+      result.keys
+    end
+
+    def tags(project_name)
+      @tags[project_name] ||= begin
+        return [] if bucket.files.nil?
+        result = {}
+        bucket.files.each do |file|
+          result[$~[1]] = true if file.key =~ /^#{project_name}\/tags\/(.+)/
+        end
+        result.keys
+      end
+    end
+
+    # This method should be called before iterating over a large set of slugs and
+    # calling #tags_for_slug on them. By doing this you are able to query all the
+    # data from AWS in advance using parallelized threads, rather than in serial.
+    def memoize_slugs_for_tags(project_name)
+      @slugs_for_tag[project_name] ||= {}
+      tag_map = tags(project_name).parallel_map do |tag|
+        next if @slugs_for_tag[project_name][tag]
+        file = nil
+        begin
+          file = bucket.files.get(tag_file_name(project_name, tag))
+        rescue Excon::Errors::Forbidden
+          # ignore 403's
+        end
+        slugs = file.nil? ? [] :  file.body.split("\n")
+        [tag, slugs]
+      end
+      tag_map.each do |tag, slugs|
+        @slugs_for_tag[project_name][tag] = slugs
+      end
+    end
+
+    def slugs_for_tag(project_name, tag)
+      @slugs_for_tag[project_name] ||= {}
+      @slugs_for_tag[project_name][tag] ||= begin
+        return [] if bucket.files.nil?
+        file = nil
+        begin
+          file = bucket.files.get(tag_file_name(project_name, tag))
+        rescue Excon::Errors::Forbidden
+          # ignore 403's
+        end
+        file.nil? ? [] :  file.body.split("\n")
+      end
+    end
+
+    def rollback_slug_for_tag(project_name, tag)
+      slugs = slugs_for_tag(project_name, tag)
+      slugs.shift
+      save_tag(project_name, tag, slugs) unless slugs.empty?
+      slugs.first
+    end
+
+    def slug_for_tag(project_name, tag)
+      slugs = slugs_for_tag(project_name, tag)
+      slugs.first
+    end
+
+    def tags_for_slug(project_name, slug_name)
+      tags = tags(project_name)
+
+      tags.select do |tag|
+        slug_for_tag(project_name, tag) == slug_name
+      end
+    end
+
+    def clone_tag(project_name, old_tag, new_tag)
+      slugs = slugs_for_tag(project_name, old_tag)
+      save_tag(project_name, new_tag, slugs)
+    end
+
+    def create_tag(project_name, tag, slug_name)
+      slugs = [slug_name]
+      slugs += slugs_for_tag(project_name, tag)
+      slugs = slugs.slice(0,10)
+      save_tag(project_name, tag, slugs)
+    end
+
+    def delete_tag(project_name, tag)
+      return nil if bucket.files.nil?
+      bucket.files.head(tag_file_name(project_name, tag)).destroy
+      @bucket_dirty = true
+    end
+
+    def save_tag(project_name, tag, slugs)
+      bucket.files.create(
+        :key    => tag_file_name(project_name, tag),
+        :body   => slugs.join("\n"),
+        :public => false
+      )
+      @bucket_dirty = true
+    end
+
+    def tag_file_name(project_name, tag)
+      [project_name, 'tags', tag].join('/')
+    end
+  end
+end

data/lib/slugforge/slugins.rb

@@ -0,0 +1,125 @@
+# Copied from Pry under the terms of the MIT license.
+# https://github.com/pry/pry/blob/0f207450a968e9e72b6e8cc8b2c21e7029569d3b/lib/pry/slugins.rb
+
+module Slugforge
+  class SluginManager
+    PREFIX = /^slugforge-/
+
+    # Placeholder when no associated gem found, displays warning
+    class NoSlugin
+      def initialize(name)
+        @name = name
+      end
+
+      def method_missing(*args)
+        warn "Warning: The slugin '#{@name}' was not found! (no gem found)"
+      end
+    end
+
+    class Slugin
+      attr_accessor :name, :gem_name, :enabled, :spec, :active
+
+      def initialize(name, gem_name, spec, enabled)
+        @name, @gem_name, @enabled, @spec = name, gem_name, enabled, spec
+      end
+
+      # Disable a slugin. (prevents slugin from being loaded, cannot
+      # disable an already activated slugin)
+      def disable!
+        self.enabled = false
+      end
+
+      # Enable a slugin. (does not load it immediately but puts on
+      # 'white list' to be loaded)
+      def enable!
+        self.enabled = true
+      end
+
+      # Load the slugin (require the gem - enables/loads the
+      # slugin immediately at point of call, even if slugin is
+      # disabled)
+      # Does not reload slugin if it's already loaded.
+      def load!
+        begin
+          require gem_name
+        rescue LoadError => e
+          warn "Found slugin #{gem_name}, but could not require '#{gem_name}.rb'"
+          warn e
+        rescue => e
+          warn "require '#{gem_name}' failed, saying: #{e}"
+        end
+
+        self.enabled = true
+      end
+
+      # Activate the slugin (run its defined activation method)
+      # Does not reactivate if already active.
+      def activate!(config)
+        return if active?
+
+        if klass = slugin_class
+          klass.activate(config) if klass.respond_to?(:activate)
+        end
+
+        self.active = true
+      end
+
+      alias active? active
+      alias enabled? enabled
+
+      private
+
+      def slugin_class
+        name = spec.name.gsub(/^slugforge-/, '').camelize
+        name = "Slugforge#{name}"
+        begin
+          name.constantize
+        rescue NameError
+          warn "Slugin #{gem_name} cannot be activated. Expected module named #{name}."
+        end
+      end
+    end
+
+    def initialize
+      @slugins = []
+      locate_slugins
+    end
+
+    # @return [Hash] A hash with all slugin names (minus the prefix) as
+    #   keys and slugin objects as values.
+    def slugins
+      h = Hash.new { |_, key| NoSlugin.new(key) }
+      @slugins.each do |slugin|
+        h[slugin.name] = slugin
+      end
+      h
+    end
+
+    # Require all enabled slugins, disabled slugins are skipped.
+    def load_slugins
+      @slugins.each(&:load!)
+    end
+
+    def activate_slugins(config)
+      @slugins.each { |s| s.activate!(config) if s.enabled? }
+    end
+
+    private
+
+    # Find all installed Pry slugins and store them in an internal array.
+    def locate_slugins
+      Gem.refresh
+      (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
+        next if gem.name !~ PREFIX
+        slugin_name = gem.name.split('-', 2).last
+        @slugins << Slugin.new(slugin_name, gem.name, gem, true) if !gem_located?(gem.name)
+      end
+      @slugins
+    end
+
+    def gem_located?(gem_name)
+      @slugins.any? { |slugin| slugin.gem_name == gem_name }
+    end
+  end
+
+end

data/lib/slugforge/version.rb

@@ -0,0 +1,9 @@
+module Slugforge
+  module Version
+    MAJOR = 4
+    MINOR = 0
+    PATCH = 0
+  end
+
+  VERSION = [Version::MAJOR, Version::MINOR, Version::PATCH].join('.')
+end

data/scripts/post-install.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+# Environment variables can be used to modify the behavior of this script. They
+# must be present in the environment of the slug when it is installed
+#
+# KILL_TIMEOUT - change the upstart kill timeout which is how long upstart will
+#                wait upon stopping a service for child processes to die before
+#                sending kill -9
+# CONCURRENCY  - Concurrency used for foreman export. Same format as concurrency
+#                argument passed for foreman
+# RUNTIME_RUBY_VERSION - The ruby version to put in the upstart templates to run the service.
+#                If specified 'rvm use $RUNTIME_RUBY_VERSION do' will prefix the process
+#                command in the Procfile
+# LOGROTATE_POSTROTATE - The shell code to run in the logrotate 'postrotate' stanza
+#                        in the logrotate config file created for this slug's upstart
+#                        service. Default is 'restart <servicename>'
+
+set -e
+
+SHARED_DIR="${INSTALL_ROOT}/shared"
+# make shared folders, if needed
+mkdir -p ${SHARED_DIR}/config
+
+linked_dirs=(log pids tmp)
+
+for d in ${linked_dirs[@]} ; do
+  mkdir -p "${SHARED_DIR}/${d}"
+  # create the symlinks for shared folders, if needed
+  if [ ! -h "$INSTALL_DIR/${d}" ] ; then
+    rm -rf "$INSTALL_DIR/${d}" # delete local copy, use shared
+    ln -s -f "${SHARED_DIR}/${d}" "${INSTALL_DIR}/${d}"
+  fi
+done
+chmod -R 775 ${SHARED_DIR}
+
+# set owner for project tree
+chown -R $OWNER ${INSTALL_ROOT}
+
+# make sure all deploy scripts are executable
+if [ -d "${INSTALL_DIR}/deploy" ] ; then
+  chmod +x ${INSTALL_DIR}/deploy/*
+fi
+
+# if environment file exists, link it into current directory so DotEnv and foreman run work
+if [ -r "${SHARED_DIR}/env" ] ; then
+  ln -s -f "${SHARED_DIR}/env" "${INSTALL_DIR}/.env"
+fi
+
+# run post_install script, if present
+if [ -r "${INSTALL_DIR}/deploy/post_install" ] ; then
+  echo "Running post_install script..."
+  # change into INSTALL_DIR so that folks can use pwd to get package install location
+  su - $OWNER -c "cd ${INSTALL_DIR}; deploy/post_install"
+fi
+
+if which service && which start && which stop > /dev/null 2>&1 ; then
+  UPSTART_PRESENT=true
+else
+  UPSTART_PRESENT=false
+fi
+
+if $UPSTART_PRESENT ; then
+  if [ -n "$CONCURRENCY" ] ; then
+    CONCURRENCY="-c $CONCURRENCY"
+
+    # split up the concurrency string into its parts and check each app to see if its
+    # unicorn or rainbows. We can only have one at a time because if they share a pid
+    # directory unicorn-upstart can't tell which process to watch.
+    # e.g.
+    # web=1,other=1 gets split on the command then app gets split on the = to be web and other
+    FOUND_UNICORN=false
+    for app in $(echo ${CONCURRENCY/,/ }) ; do
+      app=${app%=*}
+      if egrep -q "^${app}:.*(unicorn|rainbows)" "${INSTALL_DIR}/Procfile" ; then
+        if $FOUND_UNICORN ; then
+          echo "The concurrency you have set of '$CONCURRENCY' will result in two unicorn or rainbows servers running at the same time. Slug deploys do not support that."
+          echo "Update your concurrency to only run one. You can deploy also this slug again in another directory with a different concurrency to run both simultaneously."
+          exit 1
+        fi
+        FOUND_UNICORN=true
+      fi
+    done
+  fi
+
+  PROJECT_NAME=$(basename $INSTALL_ROOT)
+
+  # upstart has problems with services with dashes in them
+  PROJECT_NAME=${PROJECT_NAME/-/_}
+
+  if [ -n "$RUNTIME_RUBY_VERSION" ] ; then
+    # used inside the foreman template
+    export RUBY_CMD="rvm use $RUNTIME_RUBY_VERSION do"
+  elif [ -r "${INSTALL_DIR}/.ruby-version" ] ; then
+    export RUBY_CMD="rvm use $(head -n 1 ${INSTALL_DIR}/.ruby-version) do"
+  fi
+
+  # check for a Procfile that is not zero size
+  if [ -s "$INSTALL_DIR/Procfile" ] ; then
+    # run foreman export to export the upstart scripts
+    EXPORT_COMMAND="foreman export upstart /etc/init -a $PROJECT_NAME -f $INSTALL_DIR/Procfile -l $INSTALL_DIR/log $CONCURRENCY -t $INSTALL_DIR/deploy/upstart-templates -d $INSTALL_ROOT -u $OWNER"
+    echo "Running foreman export command '$EXPORT_COMMAND'"
+    $EXPORT_COMMAND
+
+    # start or restart the service
+    if status ${PROJECT_NAME} | grep -q running ; then
+      # restart the service
+      echo "Post install complete. Restarting ${PROJECT_NAME} service... "
+      restart ${PROJECT_NAME}
+    else
+      # start the new service
+      echo "Post install complete. Starting ${PROJECT_NAME} service... "
+      start ${PROJECT_NAME}
+    fi
+  else
+    echo "Procfile is missing or zero size. *NOT* running foreman export command."
+  fi
+else
+  echo "This machine does not appear to have upstart installed so we're skipping"
+  echo "exporting the upstart service config files."
+fi
+
+if [ -d "/etc/logrotate.d" ] ; then
+  LOGROTATE_FILE="/etc/logrotate.d/${PROJECT_NAME}"
+  LOG_DIR="${INSTALL_DIR}/log"
+  echo "Installing logrotate config ${LOGROTATE_FILE}"
+  : ${LOGROTATE_POSTROTATE:="restart ${PROJECT_NAME}"}
+  cat <<EOF > "${LOGROTATE_FILE}"
+${LOG_DIR}/*log ${LOG_DIR}/*/*.log {
+  size=10G
+  rotate 2
+  missingok
+  notifempty
+  sharedscripts
+  postrotate
+    ${LOGROTATE_POSTROTATE}
+  endscript
+}
+
+EOF
+else
+  echo "This machine does not appear to have logrotate installed so we're skipping"
+  echo "log rotation config."
+fi

data/scripts/unicorn-shepherd.sh

@@ -0,0 +1,305 @@
+#!/bin/bash
+
+# This script is a bridge between upstart and unicorn/rainbows, hereafter referred to as unicorn.
+#
+# The reason this is necessary is that upstart wants to start and watch a pid for its entire
+# lifecycle. However, unicorn's cool no-downtime restart feature creates a new unicorn master
+# which will create new workers and then kill the original master. This makes upstart think that
+# unicorn died and it gets wonky from there.
+#
+# So this script is started by upstart. It can detect if a unicorn master is already running
+# and will wait for it to exit.  Then upstart will restart this script which will see if
+# a unicorn master is running again. On no-downtime restarts it will find the new unicorn master
+# and wait on it to exit, and so on.  So unicorn is managing its own lifecycle and this script
+# gives upstart a single pid to start and watch.
+#
+# This script also handles the signals sent by upstart to stop and restart and sends them to the
+# running unicorn master to initiate a no-downtime restart when the upstart 'restart' command
+# is given to this service.
+#
+# We do some crazy magic in is_restarting to determine if we are restarting or stopping.
+
+
+#############################################################
+##
+## Set up environment
+##
+#############################################################
+
+COMMAND=$1
+SERVICE=$2
+
+# logs to syslog with service name and the pid of this script
+log() {
+    # we have to send this to syslog ourselves instead of relying on whoever launched
+    # us because the exit signal handler log output never shows up in the output stream
+    # unless we do this explicitly
+    echo "$@" | logger -t "${SERVICE}[$$]"
+}
+
+# assume upstart config cd's us into project root dir.
+BASE_DIR=$PWD
+LOG_DIR="${BASE_DIR}/log/unicorn"
+TRY_RESTART=true
+
+#############################################################
+##
+## Support functions
+##
+#############################################################
+
+# Bail out if all is not well
+check_environment(){
+    if [ "x" = "x${COMMAND}" ] ; then
+        log "Missing required argument: Command to launch unicorn or rainbows. [unicorn|rainbows]"
+        exit 1
+    fi
+
+    if [ "x" = "x${SERVICE}" ] ; then
+        log "Missing required second argument: Upstart service name that launched this script"
+        exit 1
+    fi
+
+    if [ -r $BASE_DIR/config/unicorn.rb ] ; then
+        CONFIG_FILE=$BASE_DIR/config/unicorn.rb
+    elif  [ -r $BASE_DIR/config/rainbows.rb ] ; then
+        CONFIG_FILE=$BASE_DIR/config/rainbows.rb
+    else
+        log "No unicorn or rainbows config file found in '$BASE_DIR/config'. Exiting"
+        exit 1
+    fi
+
+    # default to RAILS_ENV if RACK_ENV isn't set
+    export RACK_ENV="${RACK_ENV:-$RAILS_ENV}"
+
+    if [ ! -n "$RACK_ENV" ] ; then
+        log "Neither RACK_ENV nor RAILS_ENV environment variable are set. Exiting."
+        exit 1
+    fi
+
+}
+
+# Return the pid of the new master unicorn. If there are two master unicorns running, not
+# a new one and one marked old which is exiting, but two that think they are the master
+# then exit with an error. How could we handle this better? When would it happen?
+# Delete any pid files found which have no corresponding running processes.
+master_pid() {
+    local pid=''
+    local extra_pids=''
+    local multi_master=false
+
+    for PID_FILE in $(find $BASE_DIR/pids/ -name "*.pid") ; do
+        local p=`cat ${PID_FILE}`
+
+        if is_pid_running $p ; then
+            if [ -n "$pid" ] ; then
+                multi_master=true
+                extra_pids="$extra_pids $p"
+            else
+                pid="$p"
+            fi
+        else
+            log "Deleting ${COMMAND} pid file with no running process '$PID_FILE'"
+            rm $PID_FILE 2> /dev/null  || log "Failed to delete pid file '$PID_FILE': $!"
+        fi
+    done
+    if $multi_master ; then
+        log "Found more than one not old ${COMMAND} master process running. Pids are '$pid $extra_pids'."
+        log "Killing them all and restarting."
+        kill -9 $pid $extra_pids
+        exit 1
+    fi
+
+    echo $pid
+    # return status so we can use this function to see if the master is running
+    [ -n "$pid" ]
+}
+
+is_pid_running() {
+    local pid=$1
+    if [ ! -n "$pid" ] || ! [ -d "/proc/$pid" ] ; then
+        return 1
+    fi
+    return 0
+}
+
+
+# output parent process id of argument
+ppid() {
+    ps -p $1 -o ppid=
+}
+
+free_mem() {
+    free -m | grep "buffers/cache:" | awk '{print $4};'
+}
+
+# kills off workers whose master have died. This is indicated by a worker whose
+# parent process is the init process.
+kill_orphaned_workers() {
+    local workers=`ps aux | egrep "${COMMAND}.*worker" | grep -v grep | awk '{print $2}'`
+    for worker in $workers ; do
+        # if the worker's parent process is init, its master is dead.
+        if [ "1" = `ppid $worker` ] ; then
+            log "Found ${COMMAND} worker process with no master. Killing $worker"
+            kill -QUIT $worker
+        fi
+    done
+}
+
+# This is the on exit handler. It checks if we are restarting or not and either sends the USR2
+# signal to unicorn or, if the service is being stopped, kill the unicorn master.
+respawn_new_master() {
+    # TRY_RESTART is set to false on exit where we didn't recieve TERM.
+    # When we used "trap command TERM" it did not always trap propertly
+    # but "trap command EXIT" runs command every time no matter why the script
+    # ends. So we set this env var to false if we don't need to respawn which is if unicorn
+    # dies by itself or is restarted externally, usually through the deploy script
+    # or we never succesfully started it.
+    # If we receive a TERM, like from upstart on stop/restart, this won't be set
+    # and we'll send USR2 to restart unicorn.
+    if $TRY_RESTART ; then
+        if is_service_in_state "restart" ; then
+            local pid=`master_pid`
+            if [ -n "$pid" ] ; then
+                # free memory before restart. Restart is unreliable with not enough memory.
+                # New master crashes during startup etc.
+                let min_mem=1500
+                let workers_to_kill=8
+                let count=0
+
+                while [ `free_mem` -lt $min_mem ] && [ $count -lt $workers_to_kill ] ; do
+                    log "Sending master ${pid} TTOU to drop workers to free up memory for restart"
+                    kill -TTOU ${pid}
+                    sleep 2
+                    count=$((count + 1))
+                done
+
+                if [ `free_mem` -lt $min_mem ] ; then
+                    log "Still not enough memory to restart. Killing the master and allowing upstart to restart."
+                    kill -9 ${pid}
+                else
+                    # gracefully restart all current workers to free up RAM,
+                    #   then respawn master
+                    kill -USR2 ${pid}
+                    log "Respawn signals HUP + USR2 sent to ${COMMAND} master ${pid}"
+                fi
+            else
+                log "No ${COMMAND} master found. Exiting. A new one will launch when we are restarted."
+            fi
+        elif is_service_in_state "stop" ; then
+            local pid=`master_pid`
+            if [ -n "$pid" ] ; then
+                tries=1
+                while is_pid_running ${pid} && [ $tries -le 5 ] ; do
+                    log "Service is STOPPING. Trying to kill '${COMMAND}' at pid '${pid}'. Try ${tries}"
+                    kill ${pid}
+                    tries=$(( $tries + 1 ))
+                    sleep 1
+                done
+
+                if is_pid_running ${pid} ; then
+                    log "Done waiting for '${COMMAND}' process '${pid}' to die. Killing for realz"
+                    kill -9 ${pid}
+                else
+                    log "${COMMAND} process '${pid}' is dead."
+                fi
+            fi
+        else
+            log "Service is neither stopping nor restarting. Exiting."
+        fi
+    else
+        log "Not checking for restart"
+    fi
+}
+
+# Upstart does not have the concept of "restart". When you restart a service it is simply
+# stopped and started. But this defeats the purpose of unicorn's USR2 no downtime trick.
+# So we check the service states of the foreman exported services. If any of them are
+# start/stopping or start/post-stop it means that they are stopping but that the service
+# itself is still schedule to run. This means restart. We can use this to differentiate between
+# restarting and stopping so we can signal unicorn to restart or actually kill it appropriately.
+is_service_in_state() {
+    local STATE=$1
+    if [ "$STATE" = "restart" ] ; then
+        PATTERN="(start/stopping|start/post-stop)"
+    elif [ "$STATE" = "stop" ] ; then
+        PATTERN="/stop"
+    else
+        log "is_service_in_state: State must be one of 'stop' or 'restart'. Got '${STATE}'"
+        exit 1
+    fi
+    # the service that started us and the foreman parent services, pruning off everything
+    # after each successive dash to find parent service
+    # e.g. myservice-web-1 myservice-web myservice
+    services=( ${SERVICE} ${SERVICE%-*} ${SERVICE%%-*} )
+
+    IN_STATE=false
+
+    for service in "${services[@]}" ; do
+        if /sbin/status ${service} | egrep -q "${PATTERN}" ; then
+            log "Service ${service} is in state '${STATE}'. - '$(/sbin/status ${service})'"
+            IN_STATE=true
+        fi
+    done
+
+    $IN_STATE # this is the return code for this function
+}
+
+#############################################################
+##
+## Trap incoming signals
+##
+#############################################################
+
+# trap TERM which is what upstart uses to both stop and restart (stop/start)
+trap "respawn_new_master" EXIT
+
+#############################################################
+##
+## Main execution
+##
+#############################################################
+
+check_environment
+
+kill_orphaned_workers
+
+if ! master_pid ; then
+
+    # make sure it uses the 'currrent' symlink and not the actual path
+    export BUNDLE_GEMFILE=${BASE_DIR}/Gemfile
+
+    log "No ${COMMAND} master found. Launching new ${COMMAND} master in env '$RACK_ENV' in directory '$BASE_DIR', BUNDLE_GEMFILE=$BUNDLE_GEMFILE"
+
+    mkdir -p "${LOG_DIR}"
+
+    # setsid to start this process in a new session because when upstart stops or restarts
+    # a service it kills the entire process group of the service and relaunches it. Because
+    # we are managing the unicorn separately from upstart it needs to be in its own
+    # session (group of process groups) so that it survives the original process group
+    setsid bundle exec ${COMMAND} -E ${RACK_ENV} -c ${CONFIG_FILE} >> ${LOG_DIR}/unicorn.log 2>&1 &
+
+    tries=1
+    while [ $tries -le 10 ] && ! master_pid ; do
+        log "Waiting for unicorn to launch master"
+        tries=$(( $tries + 1 ))
+        sleep 1
+    done
+fi
+
+PID=`master_pid`
+
+if is_pid_running $PID ; then
+    # hang out while the unicorn process is alive. Once its gone we will exit
+    # this script. When upstart respawns us we will end up in the if statement above
+    # to relaunch a new unicorn master.
+    log "Found running ${COMMAND} master $PID. Awaiting its demise..."
+    while is_pid_running $PID ; do
+        sleep 5
+    done
+    log "${COMMAND} master $PID has exited."
+else
+    log "Failed to start ${COMMAND} master. Will try again on respawn. Exiting"
+fi
+
+TRY_RESTART=false