teleport 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+rdoc

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Adam Doppelt
+
+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,62 @@
+## Welcome to Teleport
+
+Teleport is a lightweight way to set up Ubuntu machines. The name derives from the mechanism that teleport uses to setup the target machine - it copies itself onto the target machine via ssh and then runs itself there. In effect, it "teleports" to the target. This design makes it possible for teleport to bootstrap itself onto a fresh machine. There's no need to install ruby or anything else by hand.
+
+Teleport strives to be **idempotent** - you can run it repeatedly without changing the result. In other words, as you build up your teleport config file you can generally run it over and over again without fear of breaking the target machine.
+
+Teleport is great for managing a small number of hosted machines, either dedicated or in the cloud. Due to it's opinionated nature and limited scope you may find that it works better for you than other, more complicated tools.
+
+At the moment Teleport supports **Ubuntu 10.04/10.10/11.04 with Ruby 1.8.7, 1.9.2, or [REE](http://www.rubyenterpriseedition.com/)**.
+
+## Getting Started
+
+1. Install Teleport on your local machine.
+
+    ```
+    $ sudo gem install teleport --pre
+    ```    
+    
+1. Create a `Telfile` config file. Here's a simple example. Note that we actually define two machines, `server_app1` and `server_db1`:
+
+    ```
+    $ mkdir ~/teleport
+    $ cd ~/teleport
+    ```
+    
+    Put this into `~/teleport/Telfile`:
+    
+    ``` ruby
+    user "admin"
+    ruby "1.9.2"
+    apt "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen", :key => "7F0CAB10"    
+    role :app, :packages => [:memcached]
+    role :db, :packages => [:mongodb-10gen]
+    server "server_app1", :role => :app
+    server "server_db1", :role => :db    
+    packages [:atop, :emacs, :gcc]
+    ```
+    
+1. You'll want to copy files to your new machines too. Put the files into your teleport directory. For example, maybe you want to automatically have your `.bashrc` and `.emacs` files copied to your new server. You'll want the `memcached` and `mongodb` config files too. Here's what your teleport directory should look like:
+
+    ```
+    Telfile
+    files/home/admin/.bashrc
+    files/home/admin/.emacs            
+    files_app/etc/default/memcached
+    files_app/etc/memcached.conf
+    files_db/etc/mongodb.conf
+    ```
+    
+1. Now run Teleport:
+
+    ```
+    $ teleport server_app1
+    ```
+    
+Teleport will ssh to the machine and set it up per your instructions.
+
+## Full Documentation
+
+Full docs are in the wiki:
+
+https://github.com/rglabs/teleport/wiki

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler"
+require "rake/rdoctask"
+
+Bundler::GemHelper.install_tasks
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "teleport #{Teleport::VERSION}"
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end

data/bin/teleport

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# in lieu of -w, since we're using env to startup
+$VERBOSE = true
+
+require "teleport"
+Teleport::Main.new

data/lib/teleport.rb

@@ -0,0 +1,7 @@
+require "teleport/constants"
+require "teleport/version"
+require "teleport/util"
+require "teleport/config"
+require "teleport/mirror"
+require "teleport/install"
+require "teleport/main"

data/lib/teleport/config.rb

@@ -0,0 +1,129 @@
+module Teleport
+  # This class parses Telfile, and includes DSL and the models.
+  class Config
+    RUBIES = ["1.9.2", "REE", "1.8.7"]
+    PATH = "Telfile"
+
+    attr_accessor :user, :ruby, :roles, :servers, :apt, :packages, :callbacks, :dsl
+    
+    def initialize
+      @roles = []
+      @servers = []
+      @apt = []
+      @packages = []
+      @callbacks = { }
+
+      @dsl = DSL.new(self)
+      @dsl.instance_eval(File.read(PATH), PATH)
+
+      @user ||= Util.whoami
+      @ruby ||= RUBIES.first
+    end
+
+    def role(n)
+      @roles.find { |i| i.name == n.to_sym }
+    end
+
+    def server(n)
+      @servers.find { |i| i.name == n.to_s }      
+    end
+
+    # The model for role in the Telfile.
+    class Role
+      attr_reader :name, :options, :packages
+      
+      def initialize(name, options)
+        raise "role name must be a sym" if !name.is_a?(Symbol)
+        raise "role options must be a hash" if !options.is_a?(Hash)
+        
+        @name, @options, @packages = name, options, []
+        if p = @options.delete(:packages)
+          raise "role :packages must be an array" if !p.is_a?(Array)
+          @packages = p
+        end
+      end
+    end
+
+    # The model for server in the Telfile.
+    class Server
+      attr_reader :name, :options, :packages
+      
+      def initialize(name, options)
+        raise "server name must be a string" if !name.is_a?(String)
+        raise "server options must be a hash" if !options.is_a?(Hash)
+        raise "server :role must be a sym" if !options[:role].is_a?(Symbol)
+        
+        @name, @options, @packages = name, options, []
+        if p = @options.delete(:packages)
+          raise "server :packages must be an array" if !p.is_a?(Array)
+          @packages = p
+        end
+      end
+    end
+
+    # The model for an apt line in the Telfile.
+    class Apt
+      attr_reader :line, :options
+
+      def initialize(line, options)
+        raise "apt line must be a string" if !line.is_a?(String)
+        raise "apt options must be a hash" if !options.is_a?(Hash)
+        @line, @options = line, options
+
+        if k = @options[:key]
+          raise "apt :key must be an String" if !k.is_a?(String)
+        end
+      end
+    end
+
+    # DSL used when parsing Telfile.
+    class DSL
+      def initialize(config)
+        @config = config
+      end
+
+      def ruby(v)
+        raise "ruby called twice" if @config.ruby
+        raise "ruby must be a string" if !v.is_a?(String)                
+        raise "don't recognize ruby #{v.inspect}." if !Config::RUBIES.include?(v)
+        @config.ruby = v
+      end
+      
+      def user(v)
+        raise "user called twice" if @config.user
+        raise "user must be a string" if !v.is_a?(String)        
+        @config.user = v
+      end
+
+      def role(name, options = {})
+        raise "role #{name.inspect} defined twice" if @config.roles.any? { |i| i.name == name }
+        @config.roles << Role.new(name, options)
+      end
+
+      def server(name, options = {})
+        raise "server #{name.inspect} defined twice" if @config.servers.any? { |i| i.name == name }
+        @config.servers << Server.new(name, options)
+      end
+
+      def apt(line, options = {})
+        @config.apt << Apt.new(line, options)
+      end
+
+      def packages(*list)
+        @config.packages += list.flatten
+      end
+
+      %w(install user packages files).each do |op|
+        %w(before after).each do |before_after|
+          callback = "#{before_after}_#{op}".to_sym
+          define_method(callback) do |&block|
+            if @config.callbacks[callback]
+              raise "you already defined the #{callback} callback"
+            end
+            @config.callbacks[callback] = block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/teleport/constants.rb

@@ -0,0 +1,19 @@
+module Constants
+  # The temp directory that teleport uses on the target machine.
+  DIR = "/tmp/_teleported"
+  
+  # The teleport gem within our temp directory.
+  GEM = "#{DIR}/gem"
+  
+  # Directory where user install data (Telfile and friends) is stored.
+  DATA = "#{DIR}/data"
+  
+  # Directory where user install files are stored.
+  FILES = "#{DIR}/data/files"
+  
+  # Name of the public key to install on the target machine.
+  PUBKEY = "id_teleport.pub"
+
+  # Minimum version of rubygems to install.
+  RUBYGEMS = "1.8.5"
+end

data/lib/teleport/install.rb

@@ -0,0 +1,227 @@
+module Teleport
+  # Class that performs the install on the target machine.
+  class Install
+    include Constants    
+    include Util
+    include Mirror    
+    
+    def initialize(config)
+      @config = config
+      run_verbose!
+      _read_config
+
+      # setup @config constants
+      Config::DSL.const_set("HOST", @host)
+      Config::DSL.const_set("USER", @config.user)
+      Config::DSL.const_set("ROLE", @role && @role.name)
+
+      # add mixins
+      @config.dsl.extend(Mirror)      
+      @config.dsl.extend(Util)
+      @config.dsl.run_verbose!
+      
+      _with_callback(:install) do
+        _gems
+        _hostname
+        _with_callback(:user) do
+          _create_user
+        end
+        _apt
+        _with_callback(:packages) do
+          _packages
+        end
+        _with_callback(:files) do
+          _files
+        end
+      end
+    end
+
+    protected
+
+    def _read_config
+      # read DIR/config to get CONFIG_HOST (and set @host)
+      config_file = { }
+      File.readlines("config").each do |i|
+        if i =~ /CONFIG_([^=]+)='([^']*)'/
+          config_file[$1.downcase.to_sym] = $2
+        end
+      end
+      @host = config_file[:host]
+
+      # do we have a server object?
+      @server = @config.server(@host)
+      if !@server && !@config.servers.empty?
+        fatal "Hm. I couldn't find server #{@host.inspect} in teleport.rb."
+      end
+
+      @role = nil
+      if @server && (role_name = @server.options[:role])
+        @role = @config.role(role_name)
+        if !@role
+          fatal "Hm. I couldn't find role #{role_name.inspect} in teleport.rb."
+        end
+      end
+    end
+
+    def _gems
+      banner "Gems..."
+
+      # update rubygems if necessary
+      gem_version = `gem --version`.strip.split(".").map(&:to_i)
+      if (gem_version <=> RUBYGEMS.split(".").map(&:to_i)) == -1
+        banner "Upgrading rubygems..."
+        run "gem update --system"
+      end
+
+      # uninstall all gems except for bundler
+      gems = `gem list`.split("\n").map { |i| i.split.first }
+      gems.delete("bundler")
+      if !gems.empty?
+        banner "Uninstalling #{gems.length} system gems..."
+        gems.each do |i|
+          run "gem uninstall -aIx #{i}"
+        end
+      end
+
+      # install bundler
+      gem_if_necessary("bundler")
+    end
+
+    def _hostname
+      banner "Hostname..."      
+      old_hostname = `hostname`.strip
+      return if old_hostname == @host
+      
+      puts "setting hostname to #{@host} (it was #{old_hostname})..."
+      File.open("/etc/hostname", "w") do |f|
+        f.write @host
+      end
+      run "hostname -F /etc/hostname"
+
+      puts "adding #{@host} to /etc/hosts ..."
+      _rewrite("/etc/hosts") do |fout|
+        hosts = File.read("/etc/hosts")
+
+        # old_hostname => @host
+        hosts.gsub!(_etc_hosts_regex(old_hostname), "\\1#{@host}\\2")
+        if hosts !~ _etc_hosts_regex(@host)
+          # not found? append to localhost
+          hosts.gsub!(_etc_hosts_regex("localhost"), "\\1localhost #{@host}\\2")
+          if hosts !~ _etc_hosts_regex(@host)
+            puts "  Hm. I couldn't add it, unfortunately. You'll have to do it manually."
+          end
+        end
+
+        fout.write hosts
+      end
+    end
+
+    def _create_user
+      user = @config.user
+      
+      banner "Creating #{user} account..."
+      # create the account
+      if !File.directory?("/home/#{user}")
+        run "useradd --create-home --shell /bin/bash --groups adm #{user}"
+      end
+
+      # try to sudo - if it fails, add user to sudoers
+      if fails?("sudo -u #{user} sudo -n echo gub")
+        puts "setting up sudoers..."
+        File.open("/etc/sudoers", "a") do |f|
+          f.puts <<EOF
+# added by teleport
+#{user} ALL=(ALL) NOPASSWD: ALL
+EOF
+        end
+      end
+
+      # ssh key, if present
+      if File.exists?(PUBKEY)
+        authorized_keys = "/home/#{user}/.ssh/authorized_keys"
+        if !File.exists?(authorized_keys)
+          puts "adding #{PUBKEY} to authorized_keys..."
+          mkdir_if_necessary(File.dirname(authorized_keys), user, 0700)
+          cp(PUBKEY, authorized_keys, user, 0600)
+        end
+      end
+    end
+
+    def _apt
+      return if @config.apt.empty?
+      banner "Apt..."
+
+      dirty = false
+      
+      # keys
+      keys = @config.apt.map { |i| i.options[:key] }.compact
+      keys.each do |i|
+        if fails?("apt-key list | grep #{i}")
+          run "apt-key adv --keyserver keyserver.ubuntu.com --recv #{i}"
+          dirty = true
+        end
+      end
+
+      # teleport.list
+      apt = @config.apt.sort_by { |i| i.line }
+      rewrite = _rewrite("/etc/apt/sources.list.d/teleport.list") do |f|
+        f.puts "# Generated by teleport"
+        apt.each do |i|
+          f.puts i.line
+        end
+      end
+
+      if dirty || rewrite
+        run "apt-get update"
+      end
+    end
+
+    def _packages
+      banner "Packages..."
+      list = @config.packages
+      list += @role.packages if @role
+      list += @server.packages if @server
+      list.sort.each { |i| package_if_necessary(i) }
+    end
+
+    def _files
+      banner "Files..."
+      files = ["files"]
+      files << "files_#{@role.name}" if @role
+      files.each do |i|
+        install_dir(i) if File.exists?("#{DATA}/#{i}")
+      end
+    end
+
+    protected
+    
+    def _with_callback(op, &block)
+      if before = @config.callbacks["before_#{op}".to_sym]
+        before.call
+      end
+      yield
+      if after = @config.callbacks["after_#{op}".to_sym]
+        after.call
+      end
+    end
+
+    def _rewrite(path, &block)
+      tmp = "#{path}.tmp"
+      begin
+        File.open(tmp, "w") { |f| yield(f) }
+        if !File.exists?(path) || different?(path, tmp)
+          copy_perms(path, tmp) if File.exists?(path)
+          mv(tmp, path)
+          return true
+        end
+      ensure
+        File.unlink(tmp) if File.exists?(tmp)
+      end
+      false
+    end
+
+    def _etc_hosts_regex(host)
+      /^([^#]+[ \t])#{Regexp.escape(host)}([ \t]|$)/ 
+    end
+  end
+end

data/lib/teleport/main.rb

@@ -0,0 +1,110 @@
+require "erb"
+require "getoptlong"
+
+module Teleport
+  # The main class for the teleport command line.
+  class Main
+    include Constants
+    include Util    
+
+    TAR = "#{DIR}.tgz"
+    
+    attr_accessor :host, :options
+    
+    def initialize(cmd = :teleport)
+      opts = GetoptLong.new(
+                            ["--help", "-h", GetoptLong::NO_ARGUMENT]
+                            )
+      opts.each do |opt, arg|
+        case opt
+        when "--help"
+          usage(0)
+        end
+      end
+
+      $stderr = $stdout
+      
+      case cmd
+      when :teleport
+        teleport(ARGV.shift)
+      when :install
+        install
+      end
+    end
+
+    def usage(exit_code)
+      puts "Usage: teleport <hostname>"
+      puts "  --help      print this help text"
+      exit(exit_code)
+    end
+
+    def read_config
+      if !File.exists?(Config::PATH)
+        fatal("Sadly, I can't find #{Config::PATH} here. Please create one.")
+      end
+      @config = Config.new
+    end
+
+    def assemble_tgz(host)
+      banner "Assembling #{TAR}..."
+      rm_and_mkdir(DIR)
+      
+      # gem
+      run("cp", ["-r", "#{File.dirname(__FILE__)}/../../lib", GEM])
+      # data
+      run("cp", ["-r", ".", DATA])
+      # config.sh
+      File.open("#{DIR}/config", "w") do |f|
+        f.puts("CONFIG_HOST='#{host}'")        
+        f.puts("CONFIG_RUBY='#{@config.ruby}'")
+        f.puts("CONFIG_RUBYGEMS='#{RUBYGEMS}'")        
+      end
+      # keys
+      ssh_key = "#{ENV["HOME"]}/.ssh/#{PUBKEY}"
+      if File.exists?(ssh_key)
+        run("cp", [ssh_key, DIR])
+      else
+        puts "Could not find #{ssh_key} - skipping."
+      end
+      
+      Dir.chdir(File.dirname(DIR)) do
+        run("tar", ["cfpz", TAR, File.basename(DIR)])
+      end
+    end
+
+    def ssh_tgz(host)
+      begin
+        banner "scp #{TAR} to #{host}:#{TAR}..."
+        run "scp #{TAR} #{host}:#{TAR}"
+
+        cmd = [
+               "cd /tmp",
+               "(sudo -n echo gub > /dev/null 2> /dev/null || (echo `whoami` could not sudo. && exit 1))",
+               "sudo rm -rf #{DIR}",
+               "sudo tar xfpz #{TAR}",
+               "sudo #{DIR}/gem/teleport/run.sh"
+              ]
+        banner "ssh to #{host} and run..."
+        run("ssh", [host, cmd.join(" && ")])
+      rescue RunError
+        fatal("Failed!")
+      end
+      banner "Success!"
+    end
+
+    def teleport(host)
+      read_config
+      usage(1) if !host
+      assemble_tgz(host)
+      ssh_tgz(host)
+    end
+
+    def install
+      Dir.chdir(DATA) do
+        read_config
+      end
+      Install.new(@config)
+    end
+    
+  end
+end

data/lib/teleport/mirror.rb

@@ -0,0 +1,103 @@
+require "erb"
+
+module Teleport
+  # Helper module for recursively mirroring files from a src to a dst.
+  module Mirror
+    include Constants
+
+    # Install file from the teleport data directory into the normal
+    # filesystem. Path can use a few different formats:
+    #
+    # * #{DATA}/xyz - Full path into the data directory
+    # * files/xyz - Path into the #{DATA}/files directory
+    # * files_role/xyz - Path into a role directory    
+    # * xyz - Assumed to be #{DATA}/files/xyz
+    #
+    # Note that the path can be an erb file. For example,
+    # "etc/hosts.erb" will be installed as "etc/hosts".
+    #
+    # Returns true if the file was installed, false if the file had
+    # previously been installed and no change was required.
+    def install_file(path)
+      path, dst = path_to_src(path), path_to_dst(path)
+
+      # run erb if necessary
+      if path =~ /#{DATA}\/(.*)\.erb$/
+        tmp = "#{DATA}/#{$1.gsub('/', '_')}"
+        dst = dst.gsub(/\.erb$/, "")
+        File.open(tmp, "w") do |f|
+          f.write ERB.new(File.read(path)).result(binding)
+        end
+        copy_metadata(path, tmp)
+        path = tmp
+      end
+      
+      cp_if_necessary(path, dst, user_for_file(dst), mode_for_file(dst))
+    end
+
+    # Install directory from the teleport data directory into the
+    # normal filesystem. Path can use a few different formats:
+    #
+    # * #{DATA}/xyz - Full path into the data directory
+    # * files/xyz - Path into the #{DATA}/files directory
+    # * files_role/xyz - Path into a role directory    
+    # * xyz - Assumed to be #{DATA}/files/xyz
+    #
+    # Returns true if the dir was installed, false if the dir had
+    # previously been installed and no change was required.
+    def install_dir(path)
+      dirty = false
+
+      path, dst = path_to_src(path), path_to_dst(path)
+      mkdir_if_necessary(dst, user_for_file(dst)) if !dst.empty?      
+      
+      files = Dir.new(path).to_a.sort
+      files.delete_if { |i| i == "." || i == ".." || i =~ /^.#/ }
+      files.each do |i|
+        i = "#{path}/#{i}"
+        if File.directory?(i)
+          dirty = install_dir(i) || dirty
+        else
+          dirty = install_file(i) || dirty
+        end
+      end
+      
+      dirty
+    end
+
+    protected
+    
+    def normalize_path(path)
+      case path
+      when /^#{DATA}/
+        # already absolute - do nothing
+      when /^files/
+        path = "#{DATA}/#{path}"
+      else
+        path = "#{DATA}/files/#{path}"
+      end
+      path
+    end
+    
+    def path_to_src(path)
+      normalize_path(path)
+    end
+
+    def path_to_dst(path)
+      path = normalize_path(path)
+      path = path[%r{#{DATA}/files[^/]*(.*)}, 1]
+      path
+    end
+
+    def user_for_file(f)
+      f[%r{^/home/([^/]+)}, 1] || "root"      
+    end
+
+    def mode_for_file(f)
+      case f
+      when %r{sudoers} then 0440
+      when %r{/\.ssh/} then 0400
+      end
+    end
+  end
+end

data/lib/teleport/run.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+
+#
+# This script runs on the target machine. First it installs ruby if
+# necessary, then it runs teleport.
+#
+
+# bail on errors
+set -eu
+
+
+
+#
+# functions
+#
+
+function banner() {
+  printf '\e[1;37;43m[%s] %-72s\e[0m\n' `date '+%H:%M:%S'` "run.sh: $1"
+}
+
+function fatal() {
+  printf '\e[1;37;41m[%s] %-72s\e[0m\n' `date '+%H:%M:%S'` "run.sh: error - $1"
+  exit 1
+}
+
+function install_ruby() {
+  banner "apt-get update / upgrade..."
+  sudo apt-get update
+  sudo apt-get -y upgrade
+  sudo apt-get install -y wget libreadline5-dev
+  
+  banner "installing Ruby $CONFIG_RUBY..."
+  case $CONFIG_RUBY in
+    1.8.7 ) install_ruby_187 ;;
+    1.9.2 ) install_ruby_192 ;;
+    REE )   install_ruby_ree ;;
+	* )     fatal "unknown ruby ($CONFIG_RUBY)" ;;
+  esac
+}
+
+function install_ruby_187() {
+  sudo apt-get -y install irb libopenssl-ruby libreadline-ruby rdoc ri ruby ruby-dev
+  
+  wget http://production.cf.rubygems.org/rubygems/rubygems-$CONFIG_RUBYGEMS.tgz
+  tar xfpz rubygems-$CONFIG_RUBYGEMS.tgz
+  (cd rubygems-$CONFIG_RUBYGEMS ; ruby setup.rb)
+  ln -s /usr/bin/gem1.8 /usr/bin/gem
+}
+
+function install_ruby_192() {
+  local patch=p180
+  
+  # see http://threebrothers.org/brendan/blog/ruby-1-9-2-on-ubuntu-11-04/
+  sudo apt-get install -y bison build-essential checkinstall libffi5 libssl-dev libyaml-dev zlib1g-dev
+
+  wget http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.2-$patch.tar.gz
+  tar xvzf ruby-1.9.2-$patch.tar.gz
+  
+  cd ruby-1.9.2-$patch
+  ./configure --prefix=/usr/local \
+              --program-suffix=1.9.2 \
+              --with-ruby-version=1.9.2 \
+              --disable-install-doc
+  make
+  sudo checkinstall -D -y \
+                    --fstrans=no \
+                    --nodoc \
+                    --pkgname="ruby1.9.2" \
+                    --pkgversion="1.9.2-$patch" \
+                    --provides="ruby"
+  cd ..
+
+  sudo update-alternatives --install /usr/local/bin/ruby ruby /usr/local/bin/ruby1.9.2 500 \
+                           --slave   /usr/local/bin/ri   ri   /usr/local/bin/ri1.9.2 \
+                           --slave   /usr/local/bin/irb  irb  /usr/local/bin/irb1.9.2 \
+                           --slave   /usr/local/bin/gem  gem  /usr/local/bin/gem1.9.2 \
+                           --slave   /usr/local/bin/erb  erb  /usr/local/bin/erb1.9.2 \
+                           --slave   /usr/local/bin/rdoc rdoc /usr/local/bin/rdoc1.9.2
+}
+
+function install_ruby_ree() {
+  local ree="ruby-enterprise_1.8.7-2011.03_${ARCH}_ubuntu10.04.deb"
+  wget http://rubyenterpriseedition.googlecode.com/files/$ree
+  sudo dpkg -i $ree
+}
+
+
+#
+# main
+#
+
+# are we on Ubuntu?
+if ! uname -a | grep -q Ubuntu ; then
+  fatal "Teleport only works with Ubuntu"
+fi
+
+# which version?
+. /etc/lsb-release
+case $($DISTRIB_RELEASE) in
+  10.* ) ;; # nop
+  11.04) ;; # nop
+  *)
+    banner "warning - Ubuntu $DISTRIB_RELEASE hasn't been tested with Teleport yet"
+esac
+
+# which architecture?
+if [ $(uname -m) == "x86_64" ] ; then
+  ARCH=amd64
+else
+  ARCH=i386
+fi
+
+# read our config
+cd /tmp/_teleported
+source ./config
+
+# do we need to install ruby?
+if ! which ruby > /dev/null ; then
+  install_ruby
+fi
+
+# run teleport!
+ruby -I gem -r teleport -e "Teleport::Main.new(:install)"

data/lib/teleport/util.rb

@@ -0,0 +1,319 @@
+require "cgi"
+require "etc"
+require "fileutils"
+
+module Teleport
+  # Helper module for executing commands and printing stuff
+  # out.
+  #
+  # The general idea is to only print commands that are actually
+  # interesting. For example, mkdir_if_necessary won't print anything
+  # if the directory already exists. That way we can scan teleport
+  # output and see what changes were made without getting lost in
+  # repetitive commands that had no actual effect.
+  module Util
+    class RunError < StandardError ; end
+
+    extend self
+    
+    RESET   = "\e[0m"
+    RED     = "\e[1;37;41m"
+    GREEN   = "\e[1;37;42m"
+    YELLOW  = "\e[1;37;43m"
+    BLUE    = "\e[1;37;44m"
+    MAGENTA = "\e[1;37;45m"
+    CYAN    = "\e[1;37;46m"
+
+    #
+    # running commands
+    #
+
+    # Make all commands echo before running.
+    def run_verbose!
+      @run_verbose = true
+    end
+    
+    # Run a command, raise an error upon failure. Output goes to
+    # $stdout/$stderr.
+    def run(command, args = nil)
+      line = nil
+      if args
+        args = args.map(&:to_s)
+        line = "#{command} #{args.join(" ")}"
+        vputs line
+        system(command, *args)
+      else
+        line = command
+        vputs line
+        system(command)
+      end
+      if $? != 0
+        if $?.termsig == Signal.list["INT"]
+          raise "#{line} interrupted"
+        end
+        raise RunError, "#{line} failed : #{$?.to_i / 256}"
+      end
+    end
+
+    # Run a command, raise an error upon failure. The output is
+    # capture as a string and returned.
+    def run_capture(command, *args)
+      if !args.empty?
+        args = args.flatten.map { |i| shell_escape(i) }.join(" ")
+        command = "#{command} #{args}"
+      end
+      result = `#{command}`
+      if $? != 0
+        if $?.termsig == Signal.list["INT"]
+          raise "#{command} interrupted"
+        end
+        raise RunError, "#{command} failed : #{$?.to_i / 256} #{result.inspect}"
+      end
+      result
+    end
+
+    # Run a command but don't send any output to $stdout/$stderr.
+    def run_quietly(command, *args)
+      if !args.empty?
+        args = args.flatten.map { |i| shell_escape(i) }.join(" ")
+        command = "#{command} #{args}"
+      end
+      run("#{command} > /dev/null 2> /dev/null")
+    end
+
+    # Run a command, return true if it succeeds.
+    def succeeds?(command)
+      system("#{command} > /dev/null 2> /dev/null")
+      $? == 0
+    end
+
+    # Run a command, return true if it fails.    
+    def fails?(command)
+      !succeeds?(command)
+    end
+
+    # Escape some text for the shell and enclose it in single quotes
+    # if necessary.
+    def shell_escape(s)
+      s = s.to_s
+      if s !~ /^[0-9A-Za-z+,.\/:=@_-]+$/
+        s = s.gsub("'") { "'\\''" }
+        s = "'#{s}'"
+      end
+      s
+    end
+
+    # Like mkdir -p. Optionally, set the owner and mode.
+    def mkdir(dir, owner = nil, mode = nil)
+      FileUtils.mkdir_p(dir, :verbose => verbose?)
+      chmod(dir, mode) if mode
+      chown(dir, owner) if owner
+    end
+
+    # mkdir only if the directory doesn't already exist. Optionally,
+    # set the owner and mode.
+    def mkdir_if_necessary(dir, owner = nil, mode = nil)
+      mkdir(dir, owner, mode) if !(File.exists?(dir) || File.symlink?(dir))
+    end
+
+    # rm a dir and recreate it.
+    def rm_and_mkdir(dir)
+      raise "don't do this" if dir == ""
+      run "rm -rf #{dir} && mkdir -p #{dir}"
+    end
+
+    # Are two files different?
+    def different?(a, b)
+      !FileUtils.compare_file(a, b)
+    end
+
+    # Copy perms from src file to dst.
+    def copy_perms(src, dst)
+      stat = File.stat(src)
+      File.chmod(stat.mode, dst)
+    end
+
+    # Copy perms and timestamps from src file to dst.
+    def copy_metadata(src, dst)
+      stat = File.stat(src)
+      File.chmod(stat.mode, dst)
+      File.utime(stat.atime, stat.mtime, dst)
+    end
+
+    # Copy file or dir from src to dst. Optionally, set the mode and
+    # owner of dst.
+    def cp(src, dst, owner = nil, mode = nil)
+      FileUtils.cp_r(src, dst, :preserve => true, :verbose => verbose?)
+      if owner && !File.symlink?(dst)      
+        chown(dst, owner) 
+      end
+      if mode
+        chmod(dst, mode)
+      end
+    end
+
+    # Copy file or dir from src to dst, but create the dst directory
+    # first if necessary. Optionally, set the mode and owner of dst.
+    def cp_with_mkdir(src, dst, owner = nil, mode = nil)
+      mkdir_if_necessary(File.dirname(dst))
+      cp(src, dst, owner, mode)
+    end
+
+    # Copy file or dir from src to dst, but ONLY if dst doesn't exist
+    # or has different contents than src. Optionally, set the mode and
+    # owner of dst.
+    def cp_if_necessary(src, dst, owner = nil, mode = nil)
+      if !File.exists?(dst) || different?(src, dst)
+        cp(src, dst, owner, mode)
+        true
+      end
+    end
+
+    # Move src to dst. Because this uses FileUtils, it works even if
+    # dst is on a different partition.
+    def mv(src, dst)
+      FileUtils.mv(src, dst, :verbose => verbose?)
+    end
+
+    # Move src to dst, but create the dst directory first if
+    # necessary.
+    def mv_with_mkdir(src, dst)
+      mkdir_if_necessary(File.dirname(dst))
+      mv(src, dst)
+    end
+
+    # Chown file to be owned by user.
+    def chown(file, user)
+      user = user.to_s
+      # who is the current owner?
+      @uids ||= {}
+      @uids[user] ||= Etc.getpwnam(user).uid
+      uid = @uids[user]
+      if File.stat(file).uid != uid
+        run "chown #{user}:#{user} '#{file}'"        
+      end
+    end
+
+    # Chmod file to a new mode.
+    def chmod(file, mode)
+      if File.stat(file).mode != mode
+        FileUtils.chmod(mode, file, :verbose => verbose?)      
+      end
+    end
+
+    # rm a file
+    def rm(file)
+      FileUtils.rm(file, :force => true, :verbose => verbose?)
+    end
+
+    # rm a file, but only if it exists.
+    def rm_if_necessary(file)
+      if File.exists?(file)
+        rm(file)
+        true
+      end
+    end
+
+    # Create a symlink from src to dst.
+    def ln(src, dst)
+      FileUtils.ln_sf(src, dst, :verbose => verbose?)
+    end
+
+    # Create a symlink from src to dst, but only if it hasn't already
+    # been created.
+    def ln_if_necessary(src, dst)
+      ln = false
+      if !File.symlink?(dst)
+        ln = true
+      elsif File.readlink(dst) != src
+        rm(dst)
+        ln = true
+      end
+      if ln
+        ln(src, dst)
+        true
+      end
+    end
+
+    # A nice printout in green.
+    def banner(s, color = GREEN)
+      s = "#{s} ".ljust(72, " ")      
+      $stderr.write "#{color}[#{Time.new.strftime('%H:%M:%S')}] #{s}#{RESET}\n"
+      $stderr.flush
+    end
+
+    # Print a warning in yellow.
+    def warning(msg)
+      banner("Warning: #{msg}", YELLOW)
+    end
+
+    # Print a fatal error in red, then exit.
+    def fatal(msg)
+      banner(msg, RED)
+      exit(1)
+    end
+
+    # Who owns this process?
+    def whoami
+      @whoami ||= Etc.getpwuid(Process.uid).name
+    end
+
+    # Returns true if the pkg is installed.
+    def package_is_installed?(pkg)
+      succeeds?("dpkg-query -f='${Status}' -W #{pkg} | grep 'install ok installed' 2> /dev/null")    
+    end
+
+    # Install pkg if necessary.
+    def package_if_necessary(pkg)
+      if !package_is_installed?(pkg)
+        banner "#{pkg}..."
+        run "apt-get -y install #{pkg}"
+      end
+    end
+
+    # Install gem if necessary.
+    def gem_if_necessary(gem)
+      grep = args = nil
+      if gem =~ /(.*)-(\d+\.\d+\.\d+)$/
+        gem, version = $1, $2
+        grep = "^#{gem}.*#{version}"
+        args = " --version #{version}"
+      else
+        grep = "^#{gem}"
+      end
+      if fails?("gem list #{gem} | grep '#{grep}'")
+        banner "#{gem}..."
+        run "gem install #{gem} #{args} --no-rdoc --no-ri"
+        return true
+      end
+      false
+    end
+
+    # Returns true if the pidfile exists and that process id exists as
+    # well.
+    def process_by_pid?(pidfile)
+      begin
+        if File.exists?(pidfile)
+          pid = File.read(pidfile).to_i
+          if pid != 0
+            Process.kill(0, pid)
+            return true
+          end
+        end
+      rescue Errno::ENOENT, Errno::ESRCH
+      end
+      false
+    end
+    
+    private
+
+    # Returns true if verbosity is turned on.
+    def verbose?
+      @run_verbose ||= nil
+    end
+
+    def vputs(s)
+      $stderr.puts s if verbose?
+    end
+  end
+end

data/lib/teleport/version.rb

@@ -0,0 +1,4 @@
+module Teleport
+  # Gem version
+  VERSION = "1.0.0"
+end

data/teleport.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "teleport/version"
+
+Gem::Specification.new do |s|
+  s.name        = "teleport"
+  s.version     = Teleport::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Doppelt"]
+  s.email       = ["amd@gurge.com"]
+  s.homepage    = "http://github.com/rglabs/teleport"  
+  s.summary     = %Q{Teleport - opinionated Ubuntu server setup with Ruby.}
+  s.description = %Q{Easy Ubuntu server setup via teleportation.}
+
+  s.rubyforge_project = "teleport"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: teleport
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Adam Doppelt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Easy Ubuntu server setup via teleportation.
+email: 
+- amd@gurge.com
+executables: 
+- teleport
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/teleport
+- lib/teleport.rb
+- lib/teleport/config.rb
+- lib/teleport/constants.rb
+- lib/teleport/install.rb
+- lib/teleport/main.rb
+- lib/teleport/mirror.rb
+- lib/teleport/run.sh
+- lib/teleport/util.rb
+- lib/teleport/version.rb
+- teleport.gemspec
+has_rdoc: true
+homepage: http://github.com/rglabs/teleport
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: teleport
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Teleport - opinionated Ubuntu server setup with Ruby.
+test_files: []
+