foreman-capistrano 0.51.0

data/README.md

@@ -0,0 +1,46 @@
+# Foreman
+
+Manage Procfile-based applications
+
+<table>
+  <tr>
+    <th>If you have...</th>
+    <th>Install with...</th>
+  </tr>
+  <tr>
+    <td>Ruby (MRI, JRuby, Windows)</td>
+    <td><pre>$ gem install foreman</pre></td>
+  </tr>
+  <tr>
+    <td>Mac OS X</td>
+    <td><a href="http://assets.foreman.io/foreman/foreman.pkg">foreman.pkg</a></td>
+  </tr>
+</table>
+
+## Getting Started
+
+* http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Documentation
+
+* [man page](http://ddollar.github.com/foreman)
+* [wiki](http://github.com/ddollar/foreman/wiki)
+* [changelog](https://github.com/ddollar/foreman/blob/master/Changelog.md)
+
+## Ports
+
+* [shoreman](https://github.com/hecticjeff/shoreman) - shell
+* [honcho](https://github.com/nickstenning/honcho) - python
+* [norman](https://github.com/josh/norman) - node.js
+
+## Authors
+
+#### Created and maintained by
+David Dollar
+
+#### Patches contributed by
+[Contributor List](https://github.com/ddollar/foreman/contributors)
+
+## License
+
+MIT

data/bin/foreman

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "foreman/cli"
+
+Foreman::CLI.start

data/bin/foreman-runner

@@ -0,0 +1,32 @@
+#!/bin/sh
+#
+#/ Usage: foreman-runner [-d <dir>] <command> [<args>...]
+#/
+#/ Run a command with exec, optionally changing directory first
+
+set -e
+
+error() {
+  echo $@ >&2
+  exit 1
+}
+
+usage() {
+  cat $0 | grep '^#/' | cut -c4-
+  exit
+}
+
+while getopts ":hd:" OPT; do
+  case $OPT in
+     d) cd "$OPTARG" ;;
+     h) usage ;;
+    \?) error "invalid option: -$OPTARG" ;;
+     :) error "option -$OPTARG requires an argument" ;;
+  esac
+done
+
+shift $((OPTIND-1))
+
+[ -z "$1" ] && usage
+
+exec "$@"

data/bin/taskman

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "foreman/cli"
+
+Foreman::CLI.engine_class = Foreman::TmuxEngine
+Foreman::CLI.start

data/data/example/Procfile

@@ -0,0 +1,4 @@
+ticker:  ruby ./ticker $PORT
+error:   ruby ./error
+utf8:    ruby ./utf8
+spawner: ./spawner

data/data/example/Procfile.without_colon

@@ -0,0 +1,2 @@
+ticker ./ticker $PORT
+error  ./error

data/data/example/error

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+
+puts "will error in 10s"
+sleep 5
+raise "Dying"

data/data/example/log/neverdie.log

@@ -0,0 +1,4 @@
+tick
+tick
+./never_die:6:in `sleep': Interrupt
+	from ./never_die:6

data/data/example/spawnee

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+NAME="$1"
+
+sigterm() {
+  echo "$NAME: got sigterm"
+}
+
+#trap sigterm SIGTERM
+
+while true; do
+  echo "$NAME: ping $$"
+  sleep 1
+done

data/data/example/spawner

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+./spawnee A &
+./spawnee B &
+./spawnee C &
+
+wait

data/data/example/ticker

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$stdout.sync = true
+
+%w( SIGINT SIGTERM ).each do |signal|
+  trap(signal) do
+    puts "received #{signal} but i'm ignoring it!"
+  end
+end
+
+while true
+  puts "tick: #{ARGV.inspect} -- FOO:#{ENV["FOO"]}"
+  sleep 1
+end

data/data/example/utf8

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: BINARY
+
+$stdout.sync = true
+
+while true
+  puts "\u65e5\u672c\u8a9e\u6587\u5b57\u5217"
+  puts "\u0915\u0932\u094d\u0907\u0928\u0643\u0637\u0628\u041a\u0430\u043b\u0438\u043d\u0430"
+  puts "\xff\x03"
+  sleep 1
+end

data/data/export/bluepill/master.pill.erb

@@ -0,0 +1,28 @@
+Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "<%= user %>"
+  app.gid = "<%= user %>"
+
+<% engine.each_process do |name, process| %>
+<% 1.upto(engine.formation[name]) do |num| %>
+  <% port = engine.port_for(process, num) %>
+  app.process("<%= name %>-<%= num %>") do |process|
+    process.start_command = "<%= process.command %>"
+
+    process.working_dir = "<%= engine.root %>"
+    process.daemonize = true
+    process.environment = <%= engine.env.merge("PORT" => port.to_s).inspect %>
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "<%= log %>/<%= app %>-<%= name %>-<%= num %>.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+
+    process.group = "<%= app %>-<%= name %>"
+  end
+<% end %>
+<% end %>
+end

data/data/export/launchd/launchd.plist.erb

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string><%= "#{app}-#{name}-#{num}" %></string>
+    <key>ProgramArguments</key>
+    <array>
+        <string><%= process.command %></string>
+    </array>
+    <key>KeepAlive</key>
+    <true/>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>StandardErrorPath</key>
+    <string><%= log %>/<%= app %>-<%= name %>-<%=num%>.log</string>
+    <key>UserName</key>
+    <string><%= user %></string>
+    <key>WorkingDirectory</key>
+    <string><%= engine.root %></string>
+</dict>
+</plist>

data/data/export/runit/log/run.erb

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+
+LOG=<%= log %>/<%= name %>-<%= num %>
+
+test -d "$LOG" || mkdir -p m2750 "$LOG" && chown <%= user %> "$LOG"
+exec chpst -u <%= user %> svlogd "$LOG"

data/data/export/runit/run.erb

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd <%= engine.root %>
+exec chpst -u <%= user %> -e <%= File.join(location, "#{process_directory}/env")  %> <%= process.command %>

data/data/export/supervisord/app.conf.erb

@@ -0,0 +1,27 @@
+<%
+app_names = []
+engine.each_process do |name, process|
+  1.upto(engine.formation[name]) do |num|
+    port = engine.port_for(process, num)
+    full_name = "#{app}-#{name}-#{num}"
+    environment = engine.env.merge("PORT" => port.to_s).map do |key, value|
+      "#{key}=#{shell_quote(value)}"
+    end
+    app_names << full_name
+%>
+[program:<%= full_name %>]
+command=<%= process.command %>
+autostart=true
+autorestart=true
+stopsignal=QUIT
+stdout_logfile=<%= log %>/<%= name %>-<%= num %>.log
+stderr_logfile=<%= log %>/<%= name %>-<%= num %>.error.log
+user=<%= user %>
+directory=<%= engine.root %>
+environment=<%= environment.join(',') %><%
+  end
+end
+%>
+
+[group:<%= app %>]
+programs=<%= app_names.join(',') %>

data/data/export/upstart/master.conf.erb

@@ -0,0 +1,8 @@
+pre-start script
+
+bash << "EOF"
+  mkdir -p <%= log %>
+  chown -R <%= user %> <%= log %>
+EOF
+
+end script

data/data/export/upstart/process.conf.erb

@@ -0,0 +1,7 @@
+start on starting <%= app %>-<%= name %>
+stop on stopping <%= app %>-<%= name %>
+respawn
+
+exec su - <%= user %> --shell=/bin/bash -c 'cd <%= engine.root %>; trap '\''kill -QUIT $(jobs -p)'\'' EXIT; export PORT=<%= port %>;<% engine.env.each_pair do |var,env| %> export <%= var.upcase %>=<%= shell_quote(env) %>; <% end %> <%= process.command %> >> <%= log %>/<%=name%>-<%=num%>.log 2>&1'
+
+

data/data/export/upstart/process_master.conf.erb

@@ -0,0 +1,2 @@
+start on starting <%= app %>
+stop on stopping <%= app %>

data/lib/foreman/capistrano.rb

@@ -0,0 +1,55 @@
+if defined?(Capistrano)
+  Capistrano::Configuration.instance(:must_exist).load do
+
+    namespace :foreman do
+      desc <<-DESC
+        Export the Procfile to upstart.  Will use sudo if available.
+
+        You can override any of these defaults by setting the variables shown below.
+
+        set :foreman_format,      "upstart"
+        set :foreman_location,    "/etc/init"
+        set :foreman_procfile,    "Procfile"
+        set :foreman_app,         application
+        set :foreman_user,        user
+        set :foreman_log,         "#{shared_path}/log"
+        set :foreman_concurrency, false
+      DESC
+      task :export, :roles => :app do
+        bundle_cmd          = fetch(:bundle_cmd, "bundle")
+        foreman_format      = fetch(:foreman_format, "upstart")
+        foreman_location    = fetch(:foreman_location, "/etc/init")
+        foreman_procfile    = fetch(:foreman_procfile, "Procfile")
+        foreman_app         = fetch(:foreman_app, application)
+        foreman_user        = fetch(:foreman_user, user)
+        foreman_log         = fetch(:foreman_log, "#{shared_path}/log")
+        foreman_concurrency = fetch(:foreman_concurrency, false)
+
+        args = ["#{foreman_format} #{foreman_location}"]
+        args << "-f #{foreman_procfile}"
+        args << "-a #{foreman_app}"
+        args << "-u #{foreman_user}"
+        args << "-l #{foreman_log}"
+        args << "-c #{foreman_concurrency}" if foreman_concurrency
+        run "cd #{release_path} && #{sudo} #{bundle_cmd} exec foreman export #{args.join(' ')}"
+      end
+
+      desc "Start the application services"
+      task :start, :roles => :app do
+        run "#{sudo} start #{application}"
+      end
+
+      desc "Stop the application services"
+      task :stop, :roles => :app do
+        run "#{sudo} stop #{application}"
+      end
+
+      desc "Restart the application services"
+      task :restart, :roles => :app do
+        run "#{sudo} start #{application} || #{sudo} restart #{application}"
+      end
+
+    end
+  end
+end
+

data/lib/foreman/cli.rb

@@ -0,0 +1,140 @@
+require "foreman"
+require "foreman/helpers"
+require "foreman/engine"
+require "foreman/engine/cli"
+require "foreman/export"
+require "foreman/version"
+require "shellwords"
+require "yaml"
+require "thor"
+
+class Foreman::CLI < Thor
+
+  include Foreman::Helpers
+
+  map ["-v", "--version"] => :version
+
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+  class_option :root,     :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
+
+  desc "start [PROCESS]", "Start the application (or a specific PROCESS)"
+
+  method_option :color,     :type => :boolean, :aliases => "-c", :desc => "Force color to be enabled"
+  method_option :env,       :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
+  method_option :formation, :type => :string,  :aliases => "-m", :banner => '"alpha=5,bar=3"'
+  method_option :port,      :type => :numeric, :aliases => "-p"
+
+  class << self
+    # Hackery. Take the run method away from Thor so that we can redefine it.
+    def is_thor_reserved_word?(word, type)
+      return false if word == "run"
+      super
+    end
+  end
+
+  def start(process=nil)
+    check_procfile!
+    load_environment!
+    engine.load_procfile(procfile)
+    engine.options[:formation] = "#{process}=1" if process
+    engine.start
+  end
+
+  desc "export FORMAT LOCATION", "Export the application to another process management format"
+
+  method_option :app,         :type => :string,  :aliases => "-a"
+  method_option :log,         :type => :string,  :aliases => "-l"
+  method_option :env,         :type => :string,  :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
+  method_option :port,        :type => :numeric, :aliases => "-p"
+  method_option :user,        :type => :string,  :aliases => "-u"
+  method_option :template,    :type => :string,  :aliases => "-t"
+  method_option :concurrency, :type => :string,  :aliases => "-c", :banner => '"alpha=5,bar=3"'
+
+  def export(format, location=nil)
+    check_procfile!
+    load_environment!
+    engine.load_procfile(procfile)
+    formatter = Foreman::Export.formatter(format)
+    formatter.new(location, engine, options).export
+  rescue Foreman::Export::Exception => ex
+    error ex.message
+  end
+
+  desc "check", "Validate your application's Procfile"
+
+  def check
+    check_procfile!
+    engine.load_procfile(procfile)
+    error "no processes defined" unless engine.processes.length > 0
+    puts "valid procfile detected (#{engine.process_names.join(', ')})"
+  end
+
+  desc "run COMMAND [ARGS...]", "Run a command using your application's environment"
+
+  method_option :env, :type => :string, :aliases => "-e", :desc => "Specify an environment file to load, defaults to .env"
+
+  def run(*args)
+    load_environment!
+    begin
+      exec engine.env, args.shelljoin
+    rescue Errno::EACCES
+      error "not executable: #{args.first}"
+    rescue Errno::ENOENT
+      error "command not found: #{args.first}"
+    end
+  end
+
+  desc "version", "Display Foreman gem version"
+
+  def version
+    puts Foreman::VERSION
+  end
+
+  no_tasks do
+    def engine
+      @engine ||= begin
+        engine_class = Foreman::Engine::CLI
+        engine = engine_class.new(options)
+        engine
+      end
+    end
+  end
+
+private ######################################################################
+
+  def error(message)
+    puts "ERROR: #{message}"
+    exit 1
+  end
+
+  def check_procfile!
+    error("#{procfile} does not exist.") unless File.exist?(procfile)
+  end
+
+  def load_environment!
+    if options[:env]
+      options[:env].split(",").each do |file|
+        engine.load_env file
+      end
+    else
+      default_env = File.join(engine.root, ".env")
+      engine.load_env default_env if File.exists?(default_env)
+    end
+  end
+
+  def procfile
+    case
+      when options[:procfile] then options[:procfile]
+      when options[:root]     then File.expand_path(File.join(options[:app_root], "Procfile"))
+      else "Procfile"
+    end
+  end
+
+  def options
+    original_options = super
+    return original_options unless File.exists?(".foreman")
+    defaults = ::YAML::load_file(".foreman") || {}
+    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+  end
+
+end

data/lib/foreman/distribution.rb

@@ -0,0 +1,9 @@
+module Foreman
+  module Distribution
+    def self.files
+      Dir[File.expand_path("../../../{bin,data,lib}/**/*", __FILE__)].select do |file|
+        File.file?(file)
+      end
+    end
+  end
+end

data/lib/foreman/engine/cli.rb

@@ -0,0 +1,104 @@
+require "foreman/engine"
+
+class Foreman::Engine::CLI < Foreman::Engine
+
+  module Color
+
+    ANSI = {
+      :reset          => 0,
+      :black          => 30,
+      :red            => 31,
+      :green          => 32,
+      :yellow         => 33,
+      :blue           => 34,
+      :magenta        => 35,
+      :cyan           => 36,
+      :white          => 37,
+      :bright_black   => 30,
+      :bright_red     => 31,
+      :bright_green   => 32,
+      :bright_yellow  => 33,
+      :bright_blue    => 34,
+      :bright_magenta => 35,
+      :bright_cyan    => 36,
+      :bright_white   => 37,
+    }
+
+    def self.enable(io, force=false)
+      io.extend(self)
+      @@color_force = force
+    end
+
+    def color?
+      return true if @@color_force
+      return false if Foreman.windows?
+      return false unless self.respond_to?(:isatty)
+      self.isatty && ENV["TERM"]
+    end
+
+    def color(name)
+      return "" unless color?
+      return "" unless ansi = ANSI[name.to_sym]
+      "\e[#{ansi}m"
+    end
+
+  end
+
+  FOREMAN_COLORS = %w( cyan yellow green magenta red blue intense_cyan intense_yellow
+                       intense_green intense_magenta intense_red, intense_blue )
+
+  def startup
+    @colors = map_colors
+    proctitle "foreman: master" unless Foreman.windows?
+    Color.enable($stdout, options[:color])
+  end
+
+  def output(name, data)
+    data.to_s.chomp.split("\n").each do |message|
+      output  = ""
+      output += $stdout.color(@colors[name.split(".").first].to_sym)
+      output += "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
+      output += $stdout.color(:reset)
+      output += message
+      $stdout.puts output
+      $stdout.flush
+    end
+  rescue Errno::EPIPE
+    terminate_gracefully
+  end
+
+  def shutdown
+  end
+
+private
+
+  def name_padding
+    @name_padding ||= begin
+      index_padding = @names.values.map { |n| formation[n] }.max.to_s.length + 1
+      name_padding  = @names.values.map { |n| n.length + index_padding }.sort.last
+      [ 6, name_padding ].max
+    end
+  end
+
+  def pad_process_name(name)
+    name.ljust(name_padding, " ")
+  end
+
+  def map_colors
+    colors = Hash.new("white")
+    @names.values.each_with_index do |name, index|
+      colors[name] = FOREMAN_COLORS[index % FOREMAN_COLORS.length]
+    end
+    colors["system"] = "intense_white"
+    colors
+  end
+
+  def proctitle(title)
+    $0 = title
+  end
+
+  def termtitle(title)
+    printf("\033]0;#{title}\007") unless Foreman.windows?
+  end
+
+end