divergence 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log/*.log
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in divergence.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,5 @@
+Copyright 2012 LayerVault Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ryan LeFevre
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# Divergence
+
+Map subdomains to git branches for switching live codebases on the fly. It's a Rack application that acts as a HTTP proxy between you and your web application for rapid testing.
+
+## Installation
+
+First, you will need to install the gem:
+
+```
+gem install divergence
+```
+
+Then, since divergence is a rackup application, you will need to initialize it somewhere by running:
+
+```
+divergence init
+```
+
+This copies all of the necessary files into the current folder for you.
+
+## Config
+
+All configuration happens in `config/config.rb`. You must set the git repository root and the application root before using divergence.
+
+You will probably want divergence to take over port 80 on your testing server, so you may have to update the forwarding host/port. Note, this is the address where your actual web application can be reached.
+
+### Callbacks
+
+Divergence lets you hook into various callbacks throughout the entire process. These are defined in `config/callbacks.rb`. Most callbacks automatically change the current working directory for you in order to make modifications as simple as possible.
+
+The available callbacks are:
+
+* before_swap
+  * Active dir: git repository
+* after_swap
+  * Active dir: application
+* before_pull
+  * Active dir: git repository
+  * Only executes if a git pull is required
+* after_pull
+  * Active dir: git repository
+  * Only executes if the git pull succeeds
+* on_pull_error
+  * Active dir: git repository
+  * Executes if there is a problem checking out and pulling a branch
+* on_branch_discover
+  * Active dir: git repository
+  * Executes if the subdomain has a dash in the name. The subdomain name is passed to the callback in the options hash.
+  * If the callback returns nil, Divergence will try to auto-detect the branch name, otherwise it will use whatever you return.
+
+There are also some built-in helper methods that are available inside callbacks. They are:
+
+* bundle_install
+* restart_passenger
+
+### Github Service Hook
+
+You can automatically keep the currently active branch up to date by using a Github service hook. In your repository on Github, go to Admin -> Service Hooks -> WebHook URLs. Add the url:
+
+```
+http://divergence.[your domain].com/update
+```
+
+Now, whenever you push code to your repository, divergence will automatically know and will update accordingly.
+
+## Running
+
+To start divergence, simply run in the divergence directory you initialized:
+
+```
+divergence start
+```
+
+This will start up divergence on port 9292 by default. If you'd like divergence to run on a different port, you can specify that as well:
+
+```
+divergence start --port=88
+```
+
+There is also a `--dev` flag that will run divergence in the foreground instead of daemonizing it.
+
+### Port 80
+
+On many systems, running on port 80 requires special permissions. If you try starting divergence, but get the error `TCPServer Error: Permission denied - bind(2)`, then you will need to run divergence with sudo (or as root). If you use RVM to manage multiple Ruby versions, then you can use `rvmsudo` instead.
+
+Make sure, if you're using Git over SSH, that you have your repository's host added to your known hosts file for the root user.
+
+### HTTPS
+
+Divergence currently does not support HTTPS on its own; however, you can still use HTTPS in combination with a load balancer if you enable SSL termination.
+
+## TODO
+
+* Handle multiple users at the same time
+* Build-in HTTPS support
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Authors
+
+* [Ryan LeFevre](http://meltingice.net) - Project Creator
+
+## License
+
+Licensed under the Apache 2.0 License. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :docs do
+  `rdoc --main lib/divergence.rb lib`
+end
+
+namespace :test do
+  Rake::TestTask.new(:rack) do |t|
+    t.libs << "test"
+    t.pattern = "test/*_test.rb"
+    t.verbose = true
+  end
+end
+
+task :test do
+  Rake::Task["test:rack"].invoke
+end

data/bin/divergence

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require "thor"
+require "thor/group"
+
+module CLI
+  class Init < Thor::Group
+    include ::Thor::Actions
+
+    desc "Initializes a divergence application into the current directory"
+
+    def self.source_root
+      ::File.expand_path('../../generators/files',  __FILE__)
+    end
+
+    def create_directories
+      empty_directory "config"
+      empty_directory "log"
+    end
+
+    def copy_templates
+      template "config.rb", "config/config.rb"
+      template "callbacks.rb", "config/callbacks.rb"
+      template "config.ru", "config.ru"
+    end
+  end
+end
+
+module CLI
+  class Base < Thor
+    register CLI::Init, "init", "init", "Initializes a divergence application into the current directory"
+
+    desc "start", "Start divergence"
+    method_options :port => :number, :dev => :boolean
+    def start
+      cmd = 'rackup'
+      cmd << " -p #{options[:port]}" if options[:port]
+      cmd << " -D" unless options[:dev]
+      
+      exec cmd
+    end
+  end
+end
+
+CLI::Base.start

data/divergence.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'divergence/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "divergence"
+  gem.version       = Divergence::VERSION
+  gem.authors       = ["Ryan LeFevre"]
+  gem.email         = ["ryan@layervault.com"]
+  gem.description   = "Map subdomains to git branches for switching live codebases on the fly. It's a Rack application that acts as a HTTP proxy between you and your web application for rapid testing."
+  gem.summary       = "Map virtual host subdomains to git branches for testing"
+  gem.homepage      = "http://cosmos.layervault.com/divergence.html"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rack"
+  gem.add_dependency "rack-proxy"
+  gem.add_dependency "thor"
+  gem.add_dependency "git"
+  gem.add_dependency "json"
+  gem.add_development_dependency "rack-test"
+end

data/generators/files/callbacks.rb

@@ -0,0 +1,9 @@
+Divergence::Application.configure do |config|
+  config.callbacks :after_swap do
+    # Run anything after the swap finishes
+    #
+    # after_swap changes to the app directory for you, so
+    # you can simply run any commands you want. There are
+    # some built-in helpers too.
+  end
+end

data/generators/files/config.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../callbacks', __FILE__)
+
+Divergence::Application.configure do |config|
+  config.git_path = nil # Change this to the git repository path
+  config.app_path = nil # and this to your application's path.
+
+  # Where should we proxy this request to? Normally you can leave
+  # the host as 'localhost', but if you are using virtual hosts in
+  # your web server setup, you may need to be more specific. You
+  # will probably want Divergence to take over port 80 as well,
+  # so update your web application to run on a different port.
+  config.forward_host = 'localhost'
+  config.forward_port = 80
+end

data/generators/files/config.ru

@@ -0,0 +1,4 @@
+require 'divergence'
+require ::File.expand_path('../config/config',  __FILE__)
+
+run Divergence::Application.new()

data/lib/divergence/config.rb

@@ -0,0 +1,58 @@
+module Divergence
+  class Configuration
+    include Enumerable
+
+    attr_accessor :app_path, :git_path
+    attr_accessor :forward_host, :forward_port
+
+    def initialize
+      @git_path = nil
+      @app_path = nil
+      @forward_host = 'localhost'
+      @forward_port = 80
+
+      @callback_store = {}
+      @helpers = Divergence::Helpers.new(self)
+    end
+
+    # Might get rid of realpath in the future because it
+    # resolves symlinks and that could be problematic
+    # with capistrano in case someone accidentally deploys.
+    def app_path=(p)
+      @app_path = File.realpath(p)
+    end
+
+    def git_path=(p)
+      @git_path = File.realpath(p)
+    end
+
+    # Lets a user define a callback for a specific event
+    def callbacks(name, &block)
+      unless @callback_store.has_key?(name)
+        @callback_store[name] = []
+      end
+
+      @callback_store[name].push block
+    end
+
+    def callback(name, args = {})
+      return unless @callback_store.has_key?(name)
+
+      Application.log.debug "Execute callback: #{name.to_s}"
+
+      @callback_store[name].each do |cb|
+        @helpers.execute cb, args
+      end
+    end
+
+    def each(&block)
+      instance_variables.each do |key|
+        if block_given?
+          block.call key, instance_variable_get(key)
+        else
+          yield instance_variable_get(key)
+        end
+      end
+    end
+  end
+end

data/lib/divergence/git_manager.rb

@@ -0,0 +1,150 @@
+module Divergence
+  class GitManager
+    attr_reader :current_branch
+
+    def initialize(config)
+      @config = config
+      @app_path = config.app_path
+      @git_path = config.git_path
+
+      @log = Logger.new('./log/git.log')
+      @git = Git.open(@git_path, :log => @log)
+
+      @current_branch = @git.branch
+      @new_branch = false
+    end
+
+    def prepare_directory(branch, force=false)
+      return if is_current?(branch) and !force
+      pull branch
+    end
+
+    # Performs the swap between the git directory and the working
+    # app directory. We want to copy the files without copying
+    # the .git directory, but this is a temporary dumb solution.
+    #
+    # Future idea: try the capistrano route and simply symlink
+    # to the git directory instead of copying files.
+    #
+    # TODO: make this more ruby-like.
+    def swap!
+      return unless @new_branch
+
+      Dir.chdir @config.git_path do
+        @config.callback :before_swap
+      end
+
+      Application.log.info "Swap: #{@git_path} -> #{@app_path}"
+      `rsync -a --delete --exclude=.git #{@git_path}/* #{@app_path}`
+      @new_branch = false
+
+      Dir.chdir @config.app_path do
+        @config.callback :after_swap
+      end
+    end
+
+    # Since underscores are technically not allowed in URLs,
+    # but they are allowed in Git branch names, we have to do
+    # some magic to possibly convert dashes to underscores
+    # so we can load the right branch.
+    #
+    # Another possible thing to explore is converting all
+    # dashes in the URL to a regex search against all branches
+    # in this repository to avoid the current brute-force
+    # solution we're using.
+    def discover(branch)
+      return branch if is_branch?(branch)
+
+      Dir.chdir @git_path do
+        resp = @config.callback :on_branch_discover, branch
+
+        unless resp.nil?
+          return resp
+        end
+      
+        local_search = "^" + branch.gsub(/-/, ".") + "$"
+        remote_search = "^remotes/origin/(" + branch.gsub(/-/, ".") + ")$"
+        local_r = Regexp.new(local_search, Regexp::IGNORECASE)
+        remote_r = Regexp.new(remote_search, Regexp::IGNORECASE)
+
+        `git branch -a`.split("\n").each do |b|
+          b = b.gsub('*', '').strip
+          
+          return b if local_r.match(b)
+          if remote_r.match(b)
+            return remote_r.match(b)[1]
+          end
+        end
+      end
+
+      raise "Unable to automatically detect branch. Given = #{branch}"
+    end
+
+    def is_current?(branch)
+      @current_branch.to_s == branch
+    end
+
+    private
+
+    def is_branch?(branch)
+      Dir.chdir @git_path do
+        # This is fast, but only works on locally checked out branches
+        `git show-ref --verify --quiet 'refs/heads/#{branch}'`
+        return true if $?.exitstatus == 0
+
+        # This is slow and will only get called for remote branches.
+        result = `git ls-remote --heads origin 'refs/heads/#{branch}'`
+        return result.strip.length != 0
+      end
+    end
+
+    def pull(branch)
+      if checkout(branch)
+        Dir.chdir @config.git_path do
+          @config.callback :before_pull
+        end
+
+        #@git.pull 'origin', branch
+        @git.chdir do
+          # For some reason, I'm having issues with the pull
+          # that's built into the library. Doing this manually
+          # for now.
+          @log.info "git pull origin #{branch} 2>&1"
+          `git pull origin #{branch} 2>&1`
+        end
+
+        Dir.chdir @config.git_path do
+          @config.callback :after_pull
+        end
+      else
+        Dir.chdir @config.git_path do
+          @config.callback :on_pull_error
+        end
+
+        return false
+      end
+    end
+
+    def checkout(branch)
+      fetch
+      reset
+      
+      begin
+        @git.checkout branch, :force => true
+        @current_branch = branch
+        @new_branch = true
+      rescue
+        return false
+      end
+    end
+
+    def reset
+      @git.reset_hard('HEAD')
+    end
+
+    # Fetch all remote branch information
+    def fetch
+      @git.fetch
+    end
+  end
+end

data/lib/divergence/helpers.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module Divergence
+  class Helpers
+    def initialize(config)
+      @config = config
+    end
+
+    def execute(block, opts={})
+      self.instance_exec opts, &block
+    end
+
+    private
+
+    def bundle_install
+      Application.log.debug "bundle install"
+      
+      Dir.chdir @config.app_path do
+        `bundle install`
+      end
+    end
+
+    def restart_passenger
+      Application.log.debug "Restarting passenger..."
+
+      Dir.chdir @config.app_path do
+        begin
+          FileUtils.touch 'tmp/restart.txt'
+        rescue
+        end
+      end
+    end
+  end
+end

data/lib/divergence/request_parser.rb

@@ -0,0 +1,52 @@
+module Divergence
+  class RequestParser
+    def initialize(env, git)
+      @req = Rack::Request.new(env)
+      @git = git
+    end
+
+    def raw
+      @req
+    end
+
+    def is_webhook?
+      subdomain == "divergence" and 
+      @req.env['PATH_INFO'] == "/update" and
+      @req.post?
+    end
+
+    def host_parts
+      @req.host.split(".")
+    end
+
+    def has_subdomain?
+      host_parts.length > 2
+    end
+
+    def subdomain
+      if has_subdomain?
+        host_parts.shift
+      else
+        nil
+      end
+    end
+
+    def branch
+      if has_subdomain?
+        branch = subdomain
+
+        if branch['-']
+          @git.discover(branch)
+        else
+          branch
+        end
+      else
+        nil
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      raw.send(meth, *args)
+    end
+  end
+end

data/lib/divergence/respond.rb

@@ -0,0 +1,71 @@
+module Divergence
+  class Application < Rack::Proxy
+    # The main entry point for the application. This is caled
+    # by Rack.
+    def call(env)
+      @req = RequestParser.new(env, @g)
+
+      # First, lets find out what subdomain/git branch
+      # we're dealing with (if any).
+      unless @req.has_subdomain?
+        # No subdomain, simply proxy the request.
+        return proxy(env)
+      end
+
+      # Handle webhooks from Github for updating the current
+      # branch if necessary.
+      if @req.is_webhook?
+        return Webhook.handle @g, @req
+      end
+
+      # Ask our GitManager to prepare the directory
+      # for the given branch.
+      result = @g.prepare_directory @req.branch
+      if result === false
+        return error!
+      end
+
+      # And then perform the codebase swap
+      @g.swap!
+
+      # We're finished, pass the request through.
+      proxy(env)
+    end
+
+    private
+
+    def proxy(env)
+      fix_environment!(env)
+      
+      status, header, body = perform_request(env)
+
+      # This is super weird. Not sure why there is a status
+      # header coming through, but Rack::Lint complains about
+      # it, so we just remove it. I think this might be coming
+      # from Cloudfront (if you use it).
+      if header.has_key?('Status')
+        header.delete 'Status'
+      end
+
+      [status, header, body]
+    end
+
+    # Sets the forwarding host for the request. This is where
+    # the proxy comes in.
+    def fix_environment!(env)
+      env["HTTP_HOST"] = "#{config.forward_host}:#{config.forward_port}"
+    end
+
+    def error!
+      Application.log.error "Branch #{@req.branch} does not exist"
+      Application.log.error @req.raw
+
+      public_path = File.expand_path('../../../public', __FILE__)
+      file = File.open("#{public_path}/404.html", "r")
+      contents = file.read
+      file.close
+
+      [404, {"Content-Type" => "text/html"}, [contents]]
+    end
+  end
+end

data/lib/divergence/version.rb

@@ -0,0 +1,3 @@
+module Divergence
+  VERSION = "0.0.1"
+end

data/lib/divergence/webhook.rb

@@ -0,0 +1,31 @@
+module Divergence
+  class Webhook
+    def self.handle(git, req)
+      hook = JSON.parse(req['payload'])
+      branch = hook["ref"].split("/").last.strip
+
+      Application.log.info "Webhook: received for #{branch} branch"
+
+      # If the webhook is for the currently active branch,
+      # then we perform a pull and a swap.
+      if git.is_current?(branch)
+        Application.log.info "Webhook: updating #{branch}"
+
+        git.prepare_directory(branch, true)
+        git.swap!
+        
+        ok
+      else
+        ignore
+      end
+    end
+
+    def self.ok
+      [200, {"Content-Type" => "text/html"}, ["OK"]]
+    end
+
+    def self.ignore
+      [200, {"Content-Type" => "text/html"}, ["IGNORE"]]
+    end
+  end
+end