servitor 0.0.1

data/lib/deployment/bundle_deployer.rb

@@ -0,0 +1,14 @@
+module Servitor
+  class BundleDeployer
+    attr_reader :box, :path
+
+    def initialize(box, path)
+      @box = box
+      @path = path
+    end
+
+    def deploy
+      box.ssh("cd '#{path}'; bundle")
+    end
+  end
+end

data/lib/deployment/deployment.rb

@@ -0,0 +1,2 @@
+servitor_require 'bundle_deployer'
+servitor_require 'envdir_deployer'

data/lib/deployment/envdir_deployer.rb

@@ -0,0 +1,34 @@
+module Servitor
+  class EnvdirDeployer
+    include ChildProcessHelper
+
+    attr_reader :box, :path, :dirname, :variables
+
+    def initialize(box, service_name, path, dirname, variables)
+      @service_name = service_name
+      @box = box
+      @path = path
+      @dirname = dirname
+      @variables = variables
+    end
+
+    def deploy
+      # envdir is part of daemontools
+      box.ssh('which envdir || sudo apt-get install daemontools',
+          :vm_name => @service_name, :ignore_exit_code => true, :capture => true)
+
+      box.ruby(<<-RUBY, :vm_name => @service_name, :sudo => true)
+        require 'fileutils'
+        envdir = File.join(#{path.inspect}, #{dirname.inspect})
+        variables = #{variables.inspect}
+        FileUtils.rm_rf(envdir)
+        FileUtils.mkdir_p(envdir)
+        Dir.chdir(envdir) do
+          variables.each do |name, value|
+            File.open(name.upcase, 'w') {|f| f.write(value.gsub("\n", 0.chr)) } if value
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/helpers/child_process_helper.rb

@@ -0,0 +1,41 @@
+module Servitor
+  module ChildProcessHelper
+
+    def execute_child_process(*args)
+      options = args.pop if args.last.is_a? Hash
+      options ||= {}
+      #puts "Executing: #{args.inspect}"
+      process = ChildProcess.build(*args)
+      if block_given?
+        yield process
+      else
+        process.io.inherit!
+      end
+      process.start
+      exit_code = process.wait
+      unless exit_code == 0 || options[:ignore_exit_code]
+        raise ServitorChildProcessError, "#{args.inspect}: exited with code #{exit_code}"
+      end
+    end
+
+    def execute_child_process_and_capture_output(*args)
+      output = nil
+      Tempfile.open('ChildProcessHelper') do |tempfile|
+        execute_child_process(*args) do |process|
+          process.io.stdout = process.io.stderr = tempfile
+        end
+        tempfile.rewind
+        output = tempfile.read
+      end
+      output
+    end
+
+    def self.included(base)
+      # this can work as a class method too
+      base.extend(ChildProcessHelper)
+    end
+
+  end
+
+  class ServitorChildProcessError < StandardError; end
+end

data/lib/helpers/helpers.rb

@@ -0,0 +1 @@
+servitor_require 'child_process_helper'

data/lib/infrastructure/infrastructure.rb

@@ -0,0 +1,16 @@
+servitor_require 'infrastructure_provisioner'
+servitor_require 'infrastructure_requirements'
+
+module Servitor
+
+  class Infrastructure
+    attr_writer :ports
+    attr_accessor :deploy_root
+
+    def ports
+      @ports || { }
+    end
+
+  end
+
+end

data/lib/infrastructure/infrastructure_provisioner.rb

@@ -0,0 +1,25 @@
+module Servitor
+
+  class InfrastructureProvisioner
+
+    class << self
+
+      # Provisions an infrastructure that meets the requirements for the given service config.
+      # Returns an infrastructure.
+      def provision(requirements)
+        VagrantBox.define(requirements) do |box|
+          VagrantBoxRubyInstaller.new(requirements).install(box)
+        end
+      end
+
+      private
+
+      def create_box
+
+
+      end
+    end
+
+  end
+
+end

data/lib/infrastructure/infrastructure_requirements.rb

@@ -0,0 +1,25 @@
+require 'zlib'
+
+module Servitor
+
+  class InfrastructureRequirements
+
+    %w(os_name os_version os_arch
+      chef_repo chef_refspec chef_runlist chef_attributes
+      ruby_version).each do |attr|
+      define_method(attr) do |*args|
+        value = args.length > 0 ? args.first : nil
+        attr_sym = "@#{attr}".to_sym
+        instance_variable_set(attr_sym, value) unless value.nil?
+        instance_variable_get(attr_sym)
+      end
+    end
+
+    # Returns a hash of the requirements that should be consistent between processes
+    def consistent_hash
+      Zlib.crc32(self.to_yaml, 0)
+    end
+
+  end
+
+end

data/lib/provisioners/Vagrantfile.erb

@@ -0,0 +1,16 @@
+Vagrant::Config.run do |config|
+  <% @services.each do |service| %>
+    config.vm.define <%= service.name.to_sym.inspect %> do |service_config|
+      service_config.vm.box = <%= service.box.to_s.inspect %>
+      service_config.vm.network :hostonly, <%= service.ip_address.to_s.inspect %>
+      <% unless service.vm_root.blank? || service.root.blank? %>
+        service_config.vm.share_folder 'v-root', <%= service.vm_root.inspect %>, <%= service.root.inspect %>
+      <% end %>
+      service_config.vm.share_folder 'ssh-keys', '/mnt/ssh', <%= @ssh_dir.inspect %>
+      #service_config.ssh.private_key_path = <%= File.join(@ssh_dir, 'id_rsa').inspect %>
+      <% service.forwarded_ports.each do |from, to| %>
+        service_config.vm.forward_port <%= from.to_i.inspect %>, <%= to.to_i.inspect %>
+      <% end %>
+    end
+  <% end %>
+end

data/lib/provisioners/provisioners.rb

@@ -0,0 +1,6 @@
+servitor_require 'vagrant_box'
+servitor_require 'veewee_box'
+servitor_require 'vagrant_box_provisioner'
+servitor_require 'vagrant_box_ruby_installer'
+servitor_require 'vagrantfile'
+servitor_require 'ssh_key'

data/lib/provisioners/ssh_key.rb

@@ -0,0 +1,22 @@
+module Servitor
+  class SshKey
+    def initialize(ssh_dir)
+      @ssh_dir = ssh_dir
+    end
+
+    def deploy
+      FileUtils.mkdir_p(@ssh_dir)
+      FileUtils.chown(ENV['USER'], nil, @ssh_dir)
+      home_ssh_dir = File.join(ENV['HOME'], '.ssh')
+      private_key_file, public_key_file = %w(id_rsa id_rsa.pub).map do |key_file|
+        File.join(home_ssh_dir, key_file).tap do |abs_key_file|
+          FileUtils.cp(abs_key_file, File.join(@ssh_dir, File.basename(abs_key_file)))
+        end
+      end
+      FileUtils.chmod(0600, private_key_file)
+      File.open(File.join(@ssh_dir, 'authorized_keys'), 'w') do |f|
+        f.write(File.read(public_key_file))
+      end
+    end
+  end
+end

data/lib/provisioners/vagrant_box.rb

@@ -0,0 +1,116 @@
+require 'vagrant'
+
+module Servitor
+
+  class VagrantBox
+
+    include ChildProcessHelper
+
+    class << self
+      def exists?(name)
+        !!self.vagrant.boxes.find(name)
+      end
+
+      def vagrant
+        @vagrant ||= Vagrant::Environment.new
+      end
+
+      def add(box_name, box_file)
+        execute_child_process('vagrant', 'box', 'add', box_name, box_file)
+      end
+
+      def define(requirements)
+        name = box_name_for(requirements)
+        return name if exists?(name)
+        box = VagrantBoxProvisioner.new(requirements).provision
+        yield box
+        box_file = box.package
+        box.destroy
+        self.add(name, box_file)
+        name
+      end
+
+      def box_file_for(name)
+        File.join(Servitor.boxes_root, "#{name}.box")
+      end
+
+      def box_name_for(requirements)
+        "servitor-#{requirements.consistent_hash.to_s(32)}"
+      end
+    end
+
+    attr_reader :name, :path
+
+    def initialize(name, path=nil)
+      @name = name
+      @path = path || File.join(Servitor.boxes_root, @name)
+    end
+
+    def init(base_box)
+      box_dir do
+        execute_child_process('vagrant', 'init', base_box)
+      end
+    end
+
+    def up
+      box_dir do
+        execute_child_process('vagrant', 'up', '--no-provision')
+      end
+    end
+
+    def halt
+      box_dir do
+        execute_child_process('vagrant', 'halt')
+      end
+    end
+
+    def destroy
+      box_dir do
+        execute_child_process('vagrant', 'destroy', '--force')
+      end
+    end
+
+    def package
+      box_dir do
+        box_file = self.class.box_file_for(@name)
+        execute_child_process('vagrant', 'package', '--output', box_file)
+        return box_file
+      end
+    end
+
+    def ssh(command, options={})
+      box_dir do
+        sudo = options[:sudo] ? 'sudo ' : ''
+        args = ['vagrant', 'ssh', options[:vm_name], '-c', "#{sudo}#{command}"].compact
+        if options[:capture]
+          execute_child_process_and_capture_output(*args)
+        else
+          execute_child_process(*args)
+        end
+      end
+    end
+
+    def ruby(script, options={})
+      escaped = script.gsub('"', '\"')
+      lines = escaped.split("\n")
+      cmd = "ruby #{lines.map {|l| "-e \"#{l}\""}.join(' ') }"
+      #puts "cmd = "+ cmd
+      ssh(cmd, options)
+    end
+
+    def provision
+      box_dir do
+        execute_child_process('vagrant', 'provision')
+      end
+    end
+
+    private
+
+    def box_dir(&block)
+      FileUtils.mkdir_p(self.path)
+      FileUtils.chdir(self.path, {}, &block)
+    end
+
+  end
+
+end

data/lib/provisioners/vagrant_box_provisioner.rb

@@ -0,0 +1,37 @@
+module Servitor
+
+  class VagrantBoxProvisioner
+    attr_reader :requirements
+
+    def initialize(requirements)
+      @requirements = requirements
+    end
+
+    def name
+      @name ||= "#{@requirements.os_name}_#{@requirements.os_version}".gsub(/[^a-zA-Z0-9\-]/, '-')
+    end
+
+    def provision
+      create_base_box unless VagrantBox.exists?(name)
+      VagrantBox.new(name).tap do |box|
+        box.init(name)
+        box.up
+      end
+    end
+
+    private
+
+    def create_base_box
+      base_box = VeeweeBox.new(name, @requirements.os_name, @requirements.os_version)
+      base_box.define
+      base_box.build(:nogui => true)
+      base_box.validate
+      base_box.export
+      base_box.up
+      box_file = "#{name}.box"
+      VagrantBox.add(name, box_file)
+      FileUtils.rm box_file
+    end
+  end
+
+end

data/lib/provisioners/vagrant_box_ruby_installer.rb

@@ -0,0 +1,34 @@
+module Servitor
+
+  class VagrantBoxRubyInstaller
+    attr_reader :requirements
+
+    def initialize(requirements)
+      @requirements = requirements
+    end
+
+    def install(box)
+      return if already_installed?(box)
+      box.ssh('which curl || sudo apt-get install curl -y')
+      case @requirements.ruby_version
+      when /jruby/
+        box.ssh('sudo apt-get install g++ openjdk-6-jre-headless -y')
+      when /ironruby/
+        box.ssh('sudo apt-get install mono-2.0-devel -y')
+      else
+        box.ssh('sudo apt-get install build-essential openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion pkg-config -y')
+      end
+      box.ssh('which rvm || curl -L https://get.rvm.io | bash -s stable', :ignore_exit_code => true)
+      box.ssh('which curl || sudo apt-get install curl -y')
+      box.ssh("rvm install #{@requirements.ruby_version}", :ignore_exit_code => true)
+      box.ssh("rvm use #{@requirements.ruby_version} --default")
+    end
+
+    private
+
+    def already_installed?(box)
+      box.ssh('rvm current', :capture => true, :ignore_exit_code => true) == @requirements.ruby_version
+    end
+  end
+
+end

data/lib/provisioners/vagrantfile.rb

@@ -0,0 +1,34 @@
+require 'erubis'
+
+class String
+  unless method_defined?(:blank?)
+    def blank?
+      self =~ /^\s*$/
+    end
+  end
+end
+
+class NilClass
+  unless method_defined?(:blank?)
+    def blank?
+      true
+    end
+  end
+end
+
+module Servitor
+
+  class Vagrantfile
+    def initialize(services, ssh_dir)
+      @services = services
+      @ssh_dir = ssh_dir
+    end
+
+    def generate
+      template_path = File.join(File.dirname(__FILE__), 'Vagrantfile.erb')
+      eruby = Erubis::Eruby.load_file(template_path)
+      context = Erubis::Context.new(:services => @services, :ssh_dir => @ssh_dir)
+      eruby.evaluate(context)
+    end
+  end
+end