dokuen 0.0.4 → 0.0.5

data/README.md

@@ -44,6 +44,8 @@ Create a `git` user and install gitolite according to [package directions](http:
 Run this:
 
 ```
+$ sudo mkdir -p /usr/local/var/dokuen
+$ cd /usr/local/var/dokuen
 $ sudo dokuen setup
 ```
 
@@ -108,3 +110,4 @@ $ ssh git@<your_host> dokuen restart_app <name>
 
 Unfortunately the stock Heroku buildpacks install a vendored node.js compiled for the Heroku platform, which happens to be linux. This doesn't work for Mac, which means you have to use a slightly patched version. This one works with a homebrew-installed node.js: https://github.com/peterkeen/heroku-buildpack-ruby
 
+

data/bin/dokuen

@@ -12,4 +12,4 @@ rescue LoadError => e
   require 'dokuen'
 end
 
-Dokuen::Cli.start()
+Dokuen::CLI.start()

data/bin/dokuen_restart_nginx

@@ -1,6 +1,3 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-require 'dokuen'
-
-Dokuen.sys("/usr/local/sbin/nginx -s reload")
+system("/usr/local/sbin/nginx -s reload") or raise "Error restarting nginx!"

data/data/templates/bin_command.erb

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+<%= @current_script %> $@ --config=<%= File.expand_path("dokuen.conf") %>

data/data/templates/deploy_command.erb

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+sudo -u <%= options[:appuser] %> <%= File.expand_path("./bin/dokuen") %> deploy --application=$APP --rev=$REV

data/data/templates/gitolite_command.erb

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+sudo -u <%= options[:appuser] %> <%= File.expand_path("./bin/dokuen") %> $@
+

data/data/templates/instructions.erb

@@ -0,0 +1,24 @@
+==== IMPORTANT INSTRUCTIONS ====
+
+In your .gitolite.rc file, in the COMMANDS section, add the following:
+
+    'dokuen' => 1
+
+In your gitolite.conf file, add the following:
+
+repo apps/[a-zA-Z0-9].*
+    C = @all
+    RW+ = CREATOR
+    config hooks.pre = "<%= File.expand_path('./bin/dokuen-deploy') %>"
+
+In your nginx.conf, add the following to your http section:
+
+include "<%= File.expand_path('nginx') %>/*.conf";
+
+Run "sudo visudo" and add the following lines:
+
+Runas_Alias	APPUSERS = <%= options[:appuser] %>
+
+git	ALL=(APPUSERS) NOPASSWD: <%= File.expand_path('./bin/dokuen') %>
+<%= options[:appuser] %>	ALL=NOPASSWD: <%= @current_bin_path %>/dokuen_restart_nginx
+

data/data/templates/mac_launchdaemon.erb

@@ -0,0 +1,19 @@
+<?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>info.bugpslat.dokuen</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string><%= File.expand_path("./bin/dokuen") %></string>
+    <string>boot</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>WorkingDirectory</key>
+  <string><%= File.expand_path(".") %></string>
+  <key>UserName</key>
+  <string<%= options[:appuser] %></string>
+</dict>
+</plist>

data/data/templates/nginx.erb

@@ -0,0 +1,22 @@
+<% if ports.length > 0 %>
+upstream <%= name %> {
+    <% ports.each do |port| %>
+    server localhost:<%= port %>;
+    <% end %>
+}
+
+server {
+    listen   80;
+    listen   443 default ssl;
+
+    server_name <%= name %>.<%= config.base_domain_name %>;
+
+    if ($ssl_protocol = "") {
+       rewrite ^   https://$server_name$request_uri? permanent;
+    }
+
+    location / {
+        proxy_pass http://<%= name %>;
+    }
+}
+<% end %>

data/data/templates/pre_receive_hook.erb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+hook = `git config hooks.pre`.chomp
+
+rev = nil
+
+STDIN.each do |line|
+  parts = line.split(/\s/)
+  next if parts[2] != "refs/heads/master"
+  rev = parts[1]
+end
+
+if hook != ""
+  name = File.basename(ENV['GL_REPO']).gsub(".git", '')
+  cmd = "env REV=#{rev} APP=#{name} #{hook}"
+  system(cmd) or raise "Error running pre-hook: #{cmd} returned #{$?}"
+end

data/data/templates/ubuntu_upstart.erb

@@ -0,0 +1,5 @@
+start at startup
+
+task
+
+exec sudo -u <%= options[:appuser] %> <%= File.expand_path("./bin/dokuen") %> boot

data/lib/dokuen/application.rb

@@ -0,0 +1,279 @@
+require 'tmpdir'
+require 'fileutils'
+require 'time'
+
+class Dokuen::Application
+
+  attr_reader :name, :config
+
+  def initialize(name, config)
+    @name = name
+    @config = config
+  end
+
+  def get_env(var)
+    with_app_dir do
+      env_path = File.join("env", var)
+      if File.exists?(env_path)
+        return File.read(env_path)
+      else
+        return nil
+      end
+    end
+  end
+
+  def set_env(var, val)
+    with_app_dir do
+      env_path = File.join("env", var)
+      File.open(env_path, "w+") do |f|
+        f.write(val)
+      end
+    end
+  end
+
+  def delete_env(var)
+    with_app_dir do
+      File.delete(File.join("env", var)) rescue nil
+    end
+  end
+
+  def env
+    vars = read_env_dir("#{config.dokuen_dir}/env")
+    with_app_dir do
+      vars.merge!(read_env_dir('env'))
+      with_current_release do
+        File.open(".env") do |f|
+          f.lines.each do |line|
+            key, val = line.split('=', 2)
+            vars[key] = val.chomp
+          end
+        end
+      end
+    end
+    vars
+  end
+
+  def create
+    Dir.chdir(File.join(config.dokuen_dir, 'apps')) do
+      if File.exists?(name)
+        raise "Application #{name} exists!"
+      end
+
+      FileUtils.mkdir_p(name)
+      with_app_dir do
+        dirs = [
+          'releases',
+          'env',
+          'logs',
+          'build'
+        ]
+        FileUtils.mkdir_p(dirs)
+      end
+    end
+  end
+
+  def deploy(revision)
+    git_dir = Dir.getwd
+
+    with_app_dir do
+      now = Time.now().utc().strftime("%Y%m%dT%H%M%S")
+      release_dir = "releases/#{now}"
+      clone_dir = clone(git_dir, revision)
+
+      buildpack = get_env('BUILDPACK_URL')
+      if buildpack
+        buildpack = "-b #{buildpack}"
+      else
+        buildpack = ''
+      end
+
+      sys("mason build #{clone_dir} #{buildpack} -o #{release_dir} -c build")
+      Dir.mkdir("#{release_dir}/.dokuen")
+
+      hook = get_env('DOKUEN_AFTER_BUILD')
+      if hook
+        sys("foreman run #{hook}")
+      end
+
+      if File.symlink?("previous")
+        File.unlink("previous")
+        File.symlink(File.readlink("current"), "previous")
+      end
+
+      if File.symlink?("current")
+        File.unlink("current")
+      end
+
+      File.symlink(File.expand_path(release_dir), "current")
+    end
+
+    scale
+    if File.symlink?("previous")
+      shutdown(File.readlink("previous"))
+    end
+  end
+
+  def scale
+    puts "Scaling..."
+    with_current_release do
+      processes = running_processes
+      running_count_by_name = {}
+  
+      processes.each do |proc, pidfile|
+        proc_name = proc.split('.')[0]
+        running_count_by_name[proc_name] ||= 0
+        running_count_by_name[proc_name] += 1
+      end
+  
+      desired_count_by_name = {}
+      scale_spec = get_env('DOKUEN_SCALE')
+      if scale_spec
+        scale_spec.split(',').each do |spec|
+          proc_name, count = spec.split('=')
+          desired_count_by_name[proc_name] = count.to_i
+        end
+      end
+  
+      to_start = []
+      to_stop = []
+  
+      desired_count_by_name.each do |proc_name, count|
+        running = running_count_by_name[proc_name] || 0
+        if running < count
+          (count - running).times do |i|
+            index = running + i + 1
+            to_start << [proc_name, index]
+          end
+        elsif running > count
+          (running - count).times do |i|
+            index = count + i + 1
+            to_stop << [proc_name, index]
+          end
+        end
+      end
+  
+      running_count_by_name.each do |proc_name, count|
+        if not desired_count_by_name.has_key?(proc_name)
+          count.times do |i|
+            to_stop << [proc_name, i]
+          end
+        end
+      end
+  
+      to_start.each do |proc_name, index|
+        port = reserve_port
+        fork do
+          Dokuen::Wrapper.new(self, proc_name, index, File.join(config.dokuen_dir, 'ports', port.to_s)).run!
+        end
+      end
+  
+      to_stop.each do |proc_name, index|
+        pid_file = processes["#{proc_name}.#{index}"]
+        pid = YAML.load(File.read(pid_file))['pid']
+        Process.kill("TERM", pid)
+      end
+      install_nginx_config
+    end
+  end
+
+  def shutdown(release)
+    with_release_dir(release) do
+      running_processes.each do |proc, pidfile|
+        pid = File.read(pidfile).to_i rescue nil
+        if pid
+          Process.kill("TERM", pid)
+        end
+      end
+    end
+  end
+
+  def install_nginx_config
+    puts "Installing nginx config"
+    sleep 2
+    @ssl_on = get_env('USE_SSL') ? 'on' : 'off'
+    @listen_port = get_env('USE_SSL') ? 443 : 80
+    conf = Dokuen.template('nginx', binding)
+    File.open(File.join(config.dokuen_dir, "nginx", "#{name}.#{config.base_domain_name}.conf"), "w+") do |f|
+      f.write(conf)
+    end
+
+    sys("sudo #{config.bin_path}/dokuen_restart_nginx")
+  end
+
+private
+
+  def clone(git_dir, revision)
+    dir = Dir.mktmpdir
+    Dir.chdir(dir) do 
+      sys("git clone #{git_dir} .")
+      sys("git checkout -q #{revision}")
+    end
+    dir
+  end
+
+  def sys(command)
+    system(command) or raise "Error running command: #{command}"
+  end
+
+  def with_app_dir
+    Dir.chdir(File.join(config.dokuen_dir, 'apps', name)) do
+      yield
+    end
+  end
+
+  def with_release_dir(release)
+    Dir.chdir(release) do
+      yield
+    end
+  end
+
+  def with_current_release
+    with_app_dir do
+      if File.symlink?("current")
+        with_release_dir(File.readlink("current")) do
+          yield
+        end
+      end
+    end
+  end
+
+  def running_processes
+    procs = {}
+    Dir.glob(".dokuen/*.pid").map do |pidfile|
+      proc_name = File.basename(pidfile).gsub('.pid', '')
+      proc_name = proc_name.gsub("dokuen.#{name}.", '')
+      procs[proc_name] = pidfile
+    end
+    procs
+  end
+
+  def read_env_dir(dir)
+    vars = {}
+    Dir.glob("#{dir}/*").each do |key|
+      vars[File.basename(key)] = File.read(key).chomp
+    end
+    vars
+  end
+
+  def reserve_port
+    ports_dir = config.dokuen_dir + "/ports"
+    port_range = config.max_port - config.min_port
+    1000.times do
+      port = rand(port_range) + config.min_port
+      path = File.join(ports_dir, port.to_s)
+      if not File.exists?(path)
+        FileUtils.touch(path)
+        return port
+      end
+    end
+    raise "Could not find free port!"
+  end
+
+  def ports
+    _ports = []
+    running_processes.each do |proc_name, pidfile|
+      _ports << YAML.load(File.read(pidfile))['port']
+    end
+    _ports
+  end
+end

data/lib/dokuen/cli.rb

@@ -1,226 +1,163 @@
-require 'rubygems'
-require 'thor'
-require 'fileutils'
+require "thor"
+require "thor/shell/basic"
+require "yaml"
 
-module Dokuen
-  class Cli < Thor
-    include Thor::Actions
-    
-    desc "setup", "Set up relevant things. Needs to be run as sudo."
-    def setup
-      raise "Must be run as root" unless Process.uid == 0
-      git_username = ask("What is your git username (usually git)?")
-      gitolite_src = ask("What is the path to your gitolite clone?")
-      say("Installing gitolite command")
-      create_file "#{gitolite_src}/src/commands/dokuen", <<HERE
-#!/bin/sh
-/usr/local/bin/dokuen $@
-HERE
-      File.chmod(0755, "#{gitolite_src}/src/commands/dokuen")
-      say("Installing gitolite hook")
-      hook_path = "/Users/#{git_username}/.gitolite/hooks/common/pre-receive"
-      create_file(hook_path, <<'HERE'
-#!/usr/bin/env ruby
-hook = `git config hooks.pre`.chomp
-
-rev = nil
-
-STDIN.each do |line|
-  parts = line.split(/\s/)
-  next if parts[2] != "refs/heads/master"
-  rev = parts[1]
-end
-
-if hook != ""
-  name = File.basename(ENV['GL_REPO'])
-  cmd = "#{hook} #{name} #{rev}"
-  system(cmd) or raise "Error running pre-hook: #{cmd} returned #{$?}"
-end
-HERE
-      )
-      File.chmod(0755, hook_path)
-      say("Creating directories")
-      dirs = [
-        '/usr/local/var/dokuen/env',
-        '/usr/local/var/dokuen/env/_common',
-        '/usr/local/var/dokuen/log',
-        '/usr/local/var/dokuen/nginx',
-        '/usr/local/var/dokuen/build',
-        '/usr/local/var/dokuen/release',
-      ]
-      FileUtils.mkdir_p(dirs, :mode => 0775)
-      FileUtils.chown(git_username, 'staff', dirs)
-
-      if yes?("Do you want to set up DNS?")
-        basename = ask("What is your DNS base domain? For example, if have a wildcard CNAME for *.example.com, this would be example.com.")
-        create_file("/usr/local/var/dokuen/env/_common/BASE_DOMAIN", basename)
-      end
-      git_hostname = `hostname`.chomp
-      if no?("Is #{git_hostname} the correct hostname for git remotes?")
-        git_hostname = ask("What hostname should we use instead?")
-      end
-      create_file("/usr/local/var/dokuen/env/_common/DOKUEN_GIT_SERVER", git_hostname)
-      create_file("/usr/local/var/dokuen/env/_common/DOKUEN_GIT_USER", git_username)
-
-      say(<<HERE
-
-==== IMPORTANT INSTRUCTIONS ====
-
-In your .gitolite.rc file, in the COMMANDS section, add the following:
-
-    'dokuen' => 1
+class Dokuen::CLI < Thor
 
-In your gitolite.conf file, add the following:
+  include Thor::Actions
 
-repo apps/[a-zA-Z0-9].*
-    C = @all
-    RW+ = CREATOR
-    config hooks.pre = "/usr/local/bin/dokuen deploy"
+  def initialize(*args)
+    super(*args)
 
-In your nginx.conf, add the following to your http section:
+    if not options[:config].nil?
+      @config = Dokuen::Config.new(options[:config])
+    end
+  end
 
-include "/usr/local/var/dokuen/nginx/*.conf";
+  class_option :application, :type => :string, :desc => "Application name"
+  class_option :config, :type => :string, :desc => "Configuration file"
+  class_option :debug, :type => :boolean, :desc => "Show backtraces"
+
+  desc "setup DIR", "set up dokuen in the given directory"
+  method_option :gituser, :desc => "Username of git user", :default => 'git'
+  method_option :gitgroup, :desc => "Group of git user", :default => 'staff'
+  method_option :appuser, :desc => "Username of app user", :default => 'dokuen'
+  method_option :gitolite, :desc => "Path to gitolite directory", :default => 'GITUSER_HOME/gitolite'
+  method_option :platform, :desc => "Which platform to install. Can be 'mac', 'ubuntu', or 'centos'", :default => 'mac'  
+  def setup(dir)
+
+    @current_script = File.expand_path($0)
+    @current_bin_path = File.dirname(@current_script)
+
+    Dir.chdir(dir) do
+      setup_dirs
+      setup_bin
+      setup_gitolite
+      write_config
+      install_boot_script
+      puts Dokuen.template('instructions', binding)
+    end
+  end
 
-Run "sudo visudo" and add the following line:
+  desc "create", "create application"
+  def create
+    Dokuen::Application.new(options[:application], @config).create
+    puts "git remote add dokuen #{@config.git_user}@#{@config.git_server}:apps/#{options[:application]}.git"
+  end
 
-git	ALL=NOPASSWD: /usr/local/bin/dokuen_install_launchdaemon, /usr/local/bin/dokuen_restart_nginx
+  desc "deploy", "deploy application", :hide => true
+  method_option :rev, :desc => "Revision to deploy"
+  def deploy
+    ENV['GIT_DIR'] = nil
+    ENV['PATH'] = "#{@config.bin_path}:#{ENV['PATH']}"
+    ENV.each do |k,v|
+      puts "#{k}=#{v}"
+    end
+    Dokuen::Application.new(options[:application], @config).deploy(options[:rev])
+  end
 
-HERE
-          )
+  desc "scale SCALE_SPEC", "scale to the given spec"
+  def scale(spec)
+    app = Dokuen::Application.new(options[:application], @config)
+    app.set_env('DOKUEN_SCALE', spec)
+    app.scale
+  end
 
+  desc "config", "show the config for the given app"
+  def config
+    app = Dokuen::Application.new(options[:application], @config)
+    app.env.each do |key, val|
+      puts "#{key}=#{val}"
     end
+  end
 
-    desc "create [APP]", "Create a new application."
-    def create(app="")
-      raise "app name required" if app.nil? || app == ""
-      read_env(app)
-      FileUtils.mkdir_p(Dokuen.dir("env", app))
-      FileUtils.mkdir_p(Dokuen.dir("release", app))
-      FileUtils.mkdir_p(Dokuen.dir("build", app))
-      puts "Created new application named #{app}"
-      puts "Git remote: #{Dokuen.base_clone_url}:apps/#{app}.git"
+  desc "config_set VARS", "set some config variables"
+  def config_set(*vars)
+    app = Dokuen::Application.new(options[:application], @config)
+    vars.each do |var|
+      key, val = var.chomp.split('=', 2)
+      app.set_env(key, val)
     end
+  end
 
-    desc "restart_app [APP]", "Restart an existing app"
-    def restart_app(app="")
-      check_app(app)
-      read_env(app)
-      deploy = Dokuen::Deploy.new(app, '', ENV['DOKUEN_RELEASE_DIR'])
-      deploy.install_launch_daemon
-      deploy.install_nginx_conf
-      puts "App restarted"
+  desc "config_delete VARS", "delete some config variables"
+  def config_delete(*vars)
+    app = Dokuen::Application.new(options[:application], @config)
+    vars.each do |var|
+      app.delete_env(var)
     end
+  end
 
-    desc "start_app [APP]", "Start an app", :hide => true
-    def start_app(app="")
-      check_app(app)
-      read_env(app)
-      ENV['PATH'] = "/usr/local/bin:#{ENV['PATH']}"
-      Dir.chdir(ENV['DOKUEN_RELEASE_DIR']) do
-        base_port = ENV['PORT'].to_i - 200
-        scale = ENV['DOKUEN_SCALE'].nil? ? "" : "-c #{ENV['DOKUEN_SCALE']}"
-        Dokuen.sys("foreman start #{scale} -p #{base_port}")
-      end
+  desc "boot", "Scale all of the current applications"
+  def boot
+    Dir.glob("#{@config.dokuen_dir}/apps/*") do |appdir|
+      next if File.basename(appdir)[0] == '.'
+      app = Dokuen::Application.new(File.basename(appdir), @config)
+      app.scale
     end
+  end
 
-    desc "scale [APP] [SCALE_SPEC]", "Scale an app to the given spec"
-    def scale(app="", scale_spec="")
-      check_app(app)
-      raise "scale spec required" if scale_spec == ""
-      read_env(app)
-      Dokuen.set_env(app, 'DOKUEN_SCALE', scale_spec)
-      restart_app(app)
-      puts "Scaled to #{scale_spec}"
-    end
+private
+
+  def setup_dirs
+    dirs = [
+      'apps',
+      'env',
+      'ports',
+      'nginx',
+      'bin'
+    ]
 
-    desc "deploy [APP] [REV]", "Deploy an app for a given revision. Run within git pre-receive.", :hide => true
-    def deploy(app="", rev="")
-      check_app(app)
-      read_env(app)
-      Dokuen::Deploy.new(app, rev).run
-      puts "App #{app} deployed"
+    dirs.each do |dir|
+      empty_directory(File.join(Dir.getwd, dir))
     end
 
-    desc "run_command [APP]", "Run a command in the given app's environment"
-    method_option :command, :aliases => '-C', :desc => "Command to run"
-    def run_command(app="")
-      check_app(app)
-      read_env(app)
+    FileUtils.chown(options[:gituser], options[:gitgroup], dirs)
+    FileUtils.chmod(0777, ['apps', 'ports', 'nginx'])
+  end
 
-      ENV['PATH'] = "/usr/local/bin:#{ENV['PATH']}"
-      Dir.chdir(ENV['DOKUEN_RELEASE_DIR']) do
-        Dokuen.sys("foreman run #{options[:command]}")
-      end
-    end
+  def setup_bin
+    @script_path = File.expand_path("bin/dokuen")
+    @deploy_script_path = File.expand_path("bin/dokuen-deploy")
+    write_template(@script_path, "bin_command", 0755)
+    write_template(@deploy_script_path, "deploy_command", 0755)
+  end
 
-    desc "config [APP] [set/delete]", "Add or remove config variables"
-    method_option :vars, :aliases => '-V', :desc => "Variables to set or remove", :type => :array
-    def config(app="", subcommand="")
-      check_app(app)
-      case subcommand
-      when "set"
-        set_vars(app)
-        restart_app(app)
-      when "delete"
-        delete_vars(app)
-        restart_app(app)
-      else
-        show_vars(app)
-      end
-    end
+  def setup_gitolite
+    githome = File.expand_path("~#{options[:gituser]}")
+    gitolite = options[:gitolite].gsub('GITUSER_HOME', githome)
 
-    desc "install_buildpack [URL]", "Add a buildpack to the mason config"
-    def install_buildpack(url="")
-      raise "URL required" unless url != ""
-      Dokuen.sys("/usr/local/bin/mason buildpacks:install #{url}")
-    end
+    write_template("#{gitolite}/src/commands/dokuen", 'gitolite_command', 0755)
+    write_template("#{githome}/.gitolite/hooks/common/pre-receive", 'pre_receive_hook', 0755)
+  end
 
-    desc "remove_buildpack [NAME]", "Remove a buildpack from the mason config"
-    def remove_buildpack(name)
-      raise "Name required" unless name != ""
-      Dokuen.sys("/usr/local/bin/mason buildpacks:uninstall #{name}")
+  def write_config
+    config = {
+      'base_domain_name' => 'dokuen',
+      'git_server'       => `hostname`.chomp,
+      'git_user'         => options[:gituser],
+      'app_user'         => options[:appuser],
+      'min_port'         => 5000,
+      'max_port'         => 6000,
+      'bin_path'         => @current_bin_path,
+      'dokuen_dir'       => File.expand_path('.')
+    }
+
+    File.open("./dokuen.conf", 'w+') do |f|
+      YAML.dump(config, f)
     end
+    
+  end
 
-    desc "buildpacks", "List the available buildpacks"
-    def buildpacks
-      Dokuen.sys("/usr/local/bin/mason buildpacks")
-    end
+  def write_template(filename, template, mode=0644)
+    t = Dokuen.template(template, binding)
+    create_file(filename, t)
+    File.chmod(mode, filename)
+  end
 
-    no_tasks do
-
-      def set_vars(app)
-        vars = options[:vars]
-        vars.each do |var|
-          key, val = var.split(/\=/)
-          Dokuen.set_env(app, key, val)
-        end
-        puts "Vars set"
-      end
-
-      def delete_vars(app)
-        vars = options[:vars]
-
-        vars.each do |var|
-          Dokuen.rm_env(app, var)
-        end
-        puts "Vars removed"
-      end
-
-      def show_vars(app)
-        read_env(app)
-        ENV.each do |key, val|
-          puts "#{key}=#{val}"
-        end
-      end
-
-      def read_env(app)
-        Dokuen.read_env("_common")
-        Dokuen.read_env(app)
-      end
-
-      def check_app(app)
-        Dokuen.app_exists?(app) or raise "App '#{app}' does not exist!"
-      end
-    end
+  def install_boot_script
+    filename, template_name = Dokuen::Platform.boot_script(options[:platform])
+    write_template(filename, template_name)
   end
+
 end

data/lib/dokuen/config.rb

@@ -0,0 +1,23 @@
+require "yaml"
+
+class Dokuen::Config
+  def initialize(path)
+    @path = path
+    @config = {}
+    read_config
+  end
+
+  def read_config
+    @config = YAML.load(File.read(@path))
+  end
+
+  def method_missing(m, *args, &block)
+    str_meth = m.to_s
+    if @config.has_key? str_meth
+      @config[str_meth]
+    else
+      super
+    end
+  end
+end
+

data/lib/dokuen/platform.rb

@@ -0,0 +1,16 @@
+module Dokuen
+  module Platform
+
+    def self.boot_script(platform)
+      case platform
+      when 'mac'
+        return "/Library/LaunchDaemons/dokuen.plist", "mac_launchdaemon"
+      when 'ubuntu'
+        return "/etc/init/dokuen", "ubuntu_upstart"
+      else
+        raise "Unknow platform: #{platform}"
+      end
+    end
+  end
+end
+      

data/lib/dokuen/version.rb

@@ -1,3 +1,3 @@
 module Dokuen
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/dokuen/wrapper.rb

@@ -0,0 +1,127 @@
+require 'foreman'
+require 'foreman/procfile'
+require 'foreman/process'
+
+class Dokuen::Wrapper
+
+  attr_reader :release_dir, :app, :proc, :index, :portfile
+
+  def initialize(app, proc, index, portfile)
+    @release_dir = Dir.getwd
+    @app = app
+    @proc = proc
+    @index = index
+    @portfile = portfile
+  end
+
+  def run!
+    return if daemonize! == nil
+    load_env
+    loop do
+      run_loop
+    end
+  end
+
+  def procname
+    "dokuen.#{app.name}.#{proc}.#{index}"
+  end
+
+  def procdir
+    File.join(release_dir, '.dokuen')
+  end
+
+  def pidfile
+    File.join(procdir, "#{procname}.pid")
+  end
+
+  def outfile
+    File.join(procdir, "#{procname}.out")
+  end
+
+  def errfile
+    File.join(procdir, "#{procname}.err")
+  end
+
+  def port
+    File.basename(portfile).to_i
+  end
+
+  def daemonize!
+    pf = File.join(pidfile)
+    raise "Process already running!" if File.exists?(pf)
+
+    return unless do_fork.nil?
+    write_pidfile
+    set_procname
+    redirect
+  end
+
+  def redirect
+    $stdin.reopen("/dev/null")
+    $stdout.sync = $stderr.sync = true
+    $stdout.reopen(File.new(outfile, "a"))
+    $stderr.reopen(File.new(errfile, "a"))
+  end
+
+  def write_pidfile
+    File.open(pidfile, "w+") do |f|
+      f.write(YAML.dump({'pid' => Process.pid, 'port' => port}))
+    end
+  end
+
+  def set_procname
+    $0 = procname
+  end
+
+  def do_fork
+    raise 'first fork failed' if (pid = fork) == -1
+    exit unless pid.nil?
+    Process.setsid
+    raise 'second fork failed' if (pid = fork) == -1
+    exit unless pid.nil?
+  end
+
+  def load_env
+    app.env.each do |key, val|
+      ENV[key] = val
+    end
+  end
+
+  def run_loop
+    reader, writer = (IO.method(:pipe).arity == 0 ? IO.pipe : IO.pipe("BINARY"))
+    procfile = Foreman::Procfile.new("Procfile")
+    entry = procfile[proc]
+    process = Foreman::Process.new(entry, index.to_i, port.to_i)
+    log_path = "../../logs/#{procname}"
+    log_file = File.open(log_path, 'a')
+
+    Signal.trap("USR2") do
+      process.kill("TERM")
+    end
+
+    Signal.trap("TERM") do
+      if not process.kill(9)
+        raise "Failed to kill process #{process.pid}"
+      end
+      File.delete(pidfile)
+      File.delete("../../../../ports/#{port}")
+      exit! 0
+    end
+
+    process.run(writer, release_dir, {})
+    thread = Thread.new do
+      loop do
+        data = reader.gets
+        next unless data
+        ps, message = data.split(",", 2)
+        log_file.puts("[#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}][#{ps}] #{message}")
+        log_file.flush
+      end
+    end
+    Process.wait(process.pid)
+    thread.exit
+    reader.close
+    writer.close
+  end
+
+end

data/lib/dokuen.rb

@@ -1,46 +1,19 @@
-require 'dokuen/cli'
-require 'dokuen/deploy'
+require "erb"
 
 module Dokuen
-  def self.dir(name, app=nil)
-    parts = ["/usr/local/var/dokuen", name]
-
-    if not app.nil?
-      parts << app
-    end
-      
-    File.join(parts)
-  end
-
-  def self.sys(command)
-    system(command) or raise "Error running #{command}"
-  end
-
-  def self.read_env(name)
-    env_dir = Dokuen.dir('env', name)
-    Dir.glob("#{env_dir}/*") do |var|
-      var_name = File.basename(var)
-      ENV[var_name] = File.open(var).read().chomp()
-    end
-  end
-
-  def self.set_env(name, key, value)
-    env_dir = Dokuen.dir('env', name)
-    File.open(File.join(env_dir, key), "w+") do |f|
-      f.write value
+  def self.template(name, bind)
+    path = File.expand_path("../../data/templates/#{name}.erb", __FILE__)
+    if File.exists?(path)
+      t = ERB.new(File.read(path))
+      t.result(bind)
+    else
+      raise "Unknown template: #{name}"
     end
   end
-
-  def self.rm_env(name, key)
-    env_dir = Dokuen.dir('env', name)
-    File.delete(File.join(env_dir, key))
-  end
-
-  def self.base_clone_url
-    "#{ENV['DOKUEN_GIT_USER']}@#{ENV['DOKUEN_GIT_SERVER']}"
-  end
-
-  def self.app_exists?(name)
-    File.exists?(Dokuen.dir('env', name))
-  end
 end
+
+require "dokuen/cli"
+require "dokuen/config"
+require "dokuen/application"
+require "dokuen/wrapper"
+require "dokuen/platform"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dokuen
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-21 00:00:00.000000000Z
+date: 2012-05-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -91,11 +91,22 @@ files:
 - bin/dokuen
 - bin/dokuen_install_launchdaemon
 - bin/dokuen_restart_nginx
+- data/templates/bin_command.erb
+- data/templates/deploy_command.erb
+- data/templates/gitolite_command.erb
+- data/templates/instructions.erb
+- data/templates/mac_launchdaemon.erb
+- data/templates/nginx.erb
+- data/templates/pre_receive_hook.erb
+- data/templates/ubuntu_upstart.erb
 - dokuen.gemspec
 - lib/dokuen.rb
+- lib/dokuen/application.rb
 - lib/dokuen/cli.rb
-- lib/dokuen/deploy.rb
+- lib/dokuen/config.rb
+- lib/dokuen/platform.rb
 - lib/dokuen/version.rb
+- lib/dokuen/wrapper.rb
 homepage: https://github.com/peterkeen/dokuen
 licenses: []
 post_install_message: 

data/lib/dokuen/deploy.rb

@@ -1,173 +0,0 @@
-require 'tmpdir'
-require 'fileutils'
-require 'time'
-require 'erb'
-
-module Dokuen
-  class Deploy
-
-    def initialize(app, rev, release_dir=nil)
-      @app = app || app_name_from_env
-      @rev = rev
-      ENV['GIT_DIR'] = nil
-      ENV['PATH'] = "/usr/local/bin:#{ENV['PATH']}"
-      if release_dir
-        @release_dir = release_dir
-      end
-    end
-
-    def run
-      read_app_env
-      make_dirs
-      clone
-      build
-      install_launch_daemon
-      install_nginx_conf
-    end
-
-    def read_app_env
-      Dokuen.read_env('_common')
-      Dokuen.read_env(@app)
-    end
-
-    def make_dirs
-      FileUtils.mkdir_p([
-        env_dir,
-        release_dir,
-        cache_dir,
-        nginx_dir
-      ])
-    end
-
-    def clone
-      Dokuen.sys("git clone #{git_dir} #{clone_dir}")
-      Dir.chdir(clone_dir)
-      Dokuen.sys("git checkout #{@rev}")
-    end
-
-    def build
-      Dokuen.sys("mason build #{clone_dir} #{buildpack} -o #{release_dir} -c #{cache_dir}")
-      Dokuen.sys("chmod -R a+r #{release_dir}")
-      Dokuen.sys("find #{release_dir} -type d -exec chmod a+x {} \\;")
-      Dokuen.set_env(@app, 'DOKUEN_RELEASE_DIR', release_dir)
-
-      hook = ENV['DOKUEN_AFTER_BUILD']
-      if not hook.nil?
-        Dir.chdir release_dir do
-          Dokuen.sys("foreman run #{hook}")
-        end
-      end
-    end
-
-    def buildpack
-      if not ENV['BUILDPACK_URL'].nil?
-        "-b #{ENV['BUILDPACK_URL']}"
-      else
-        ""
-      end
-    end
-
-    def install_launch_daemon
-      t = ERB.new(launch_daemon_template)
-      plist_path = File.join(release_dir, "dokuen.#{@app}.plist")
-      File.open(plist_path, "w+") do |f|
-        f.write(t.result(binding))
-      end
-      Dokuen.sys("sudo /usr/local/bin/dokuen_install_launchdaemon #{plist_path}")
-    end
-
-    def install_nginx_conf
-      t = ERB.new(nginx_template)
-      File.open(File.join(nginx_dir, "#{@app}.#{base_domain}.conf"), "w+") do |f|
-        f.write(t.result(binding))
-      end
-      Dokuen.sys("sudo /usr/local/bin/dokuen_restart_nginx")
-    end
-
-    def base_domain
-      ENV['BASE_DOMAIN'] || 'dokuen'
-    end
-
-    def app_name_from_env
-      File.basename(ENV['GL_REPO']).gsub(/\.git$/, '')
-    end
-
-    def env_dir
-      Dokuen.dir("env", @app)
-    end
-
-    def clone_dir
-      @clone_dir ||= Dir.mktmpdir
-    end
-
-    def git_dir
-      @git_dir || Dir.getwd
-    end
-
-    def release_dir
-      @now = Time.now().utc().strftime("%Y%m%dT%H%M%S")
-      @release_dir ||= File.join(Dokuen.dir('release', @app), @now)
-    end
-
-    def cache_dir
-      Dokuen.dir('build', @app)
-    end
-
-    def nginx_dir
-      Dokuen.dir('nginx')
-    end
-
-    def server_port
-      ENV['USE_SSL'] ? "443" : "80"
-    end
-    
-    def ssl_on
-      ENV['USE_SSL'] ? "on" : "off"
-    end
-
-    def launch_daemon_template
-      <<HERE
-<?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>KeepAlive</key>
-  <true/>
-  <key>Label</key>
-  <string>dokuen.<%= @app %></string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>/usr/local/bin/dokuen</string>
-    <string>start_app</string>
-    <string><%= @app %></string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>UserName</key>
-  <string>peter</string>
-  <key>WorkingDirectory</key>
-  <string>/usr/local/var/dokuen</string>
-  <key>StandardOutPath</key>
-  <string>/usr/local/var/dokuen/log/<%= @app %>.log</string>
-  <key>StandardErrorPath</key>
-  <string>/usr/local/var/dokuen/log/<%= @app %>.log</string>
-</dict>
-</plist>
-HERE
-    end
-
-    def nginx_template
-      <<HERE
-server {
-  server_name <%= @app %>.<%= base_domain %>;
-  listen <%= server_port %>;
-  ssl <%= ssl_on %>;
-  location / {
-    proxy_pass http://localhost:<%= ENV['PORT'] %>/;
-  }
-}
-HERE
-    end
-  end
-end
-