annex 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+config/settings.yml

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,40 @@
+== Annex
+
+Annex leverages chef-solo to allow you to provision and update multiple
+servers by looking up network topology on the fly utilizing a distributed
+repository to manage recipes.
+
+== Getting started
+
+The `annex` command allows you to provision a server (bootstrapping or
+updating as needed) or list the servers that you have already provisioned.
+
+    Usage: annex [-v] [-h] command [<args>]
+
+    Available commands:
+
+        provision
+        list
+
+    Global options:
+
+        -h, --help                       Show this message
+        -v, --version                    Show version
+
+In order for this to work, your recipes have to be setup and your
+config/settings.yml needs to be setup.
+
+== Testing
+
+Nope.
+
+== Contributors
+
+* Jeff Rafter
+* Your name here
+
+== Acknowledgements
+
+Thanks to Mitchell Hashimoto ({@mitchellh}[link:https://twitter.com/#!/mitchellh]) and
+Nick Plante ({@zapnap}[link:https://twitter.com/#!/zapnap]).
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/annex.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "annex/version"
+
+Gem::Specification.new do |s|
+  s.name        = "annex"
+  s.version     = Annex::VERSION
+  s.authors     = ["Jeff Rafter"]
+  s.email       = ["jeffrafter@gmail.com"]
+  s.homepage    = "http://github.com/jeffrafter/annex"
+  s.summary     = %q{Quickly provision servers using chef-solo and no central server.}
+  s.description = %q{Annex leverages chef-solo to allow you to provision and update mutliple servers by looking up network topology on the fly utilizing a distributed repository to manage recipes"}
+
+  s.rubyforge_project = "annex"
+
+  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"]
+
+  s.add_runtime_dependency("fog", [">= 0"])
+  s.add_runtime_dependency("json", [">= 0"])
+end

data/bin/annex

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+# Trap interrupts to quit cleanly.
+Signal.trap("INT") { exit 1 }
+
+require 'annex'
+require 'annex/cli'
+
+# Stdout/stderr should not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# Initialization options
+opts = {}
+
+# Are we running on Windows?
+opts[:windows] = RbConfig::CONFIG["host_os"].downcase =~ /(mingw|mswin)/
+
+# Disable color if the proper argument was passed or if we're
+# on Windows since the default Windows terminal doesn't support
+# colors.
+opts[:support_colors] = opts[:windows] && ENV.has_key?("ANSICON")
+opts[:no_colors] = ARGV.include?("--no-color") || !$stdout.tty? || !opts[:supports_colors]
+ARGV.delete("--no-color")
+
+env = nil
+begin
+  # Create the environment, which is the cwd of wherever the
+  # `annex` command was invoked from
+  env = Annex::Environment.new(opts)
+
+  # Execute the CLI interface, and exit with the proper error code
+  exit(env.cli(ARGV))
+
+rescue Annex::Errors::AnnexError => e
+  if env
+    env.ui.error e.message, {:prefix => false} if e.message
+  else
+    $stderr.puts "Annex failed to initialize at a very early stage:\n\n"
+    $stderr.puts e.message
+  end
+
+  exit e.status_code if e.respond_to?(:status_code)
+
+  # An error occurred with no status code defined
+  exit 999
+end

data/config/settings.yml.example

@@ -0,0 +1,61 @@
+repository: YOUR_PRIVATE_REPO
+users:
+  bootstrap: ubuntu
+  update: youruser
+amazon:
+  access_key_id: AMAZON_KEY_HERE
+  secret_access_key: AMAZON_SECRET_HERE
+  images:
+    ebs:
+      image_id: ami-63be790a
+      flavor_id: m2.2xlarge
+    ec2:
+      image_id: ami-35de095c
+      flavor_id: m1.large
+    ec2_small_32:
+      image_id: ami-81b275e8
+      flavor_id: m1.small
+    ebs_micro:
+      image_id: ami-71dc0b18
+      flavor_id: t1.micro
+    windows:
+      image_id: ami-92ba43fb
+      flavor_id: m1.small
+roles:
+  web:
+    image: ec2
+    count: 2
+  app:
+    image: ec2
+    count: 1
+  utility:
+    image: ec2
+    count: 1
+  redis:
+    image: ec2
+    count: 1
+  "redis-slave":
+    image: ec2
+    count: 1
+  ci:
+    ruby: package
+    image: ec2_small_32
+    count: 1
+  qa:
+    image: ec2
+    count: 1
+  dns:
+    ruby: package
+    image: ebs_micro
+    count: 1
+  windows:
+    image: windows
+    count: 1
+  staging:
+    image: ec2
+    count: 1
+  monitoring:
+    ruby: package
+    image: ec2_small_32
+    count: 1
+

data/lib/annex.rb

@@ -0,0 +1,9 @@
+require "annex/version"
+require "annex/errors"
+require "annex/environment"
+require "annex/command"
+require "annex/list"
+require "annex/provision"
+
+module Annex
+end

data/lib/annex/cli.rb

@@ -0,0 +1,119 @@
+require 'optparse'
+
+module Annex
+  # Manages the command line interface to Annex
+  class CLI
+    COMMANDS = %w(provision list)
+
+    def initialize(argv, env)
+      @argv = argv
+      @env  = env
+    end
+
+    def execute
+      exit_code = 0
+      return exit_code unless options = parse(@argv.dup)
+      command = case options[:command]
+      when "provision"
+        Annex::Provision.new(@env, options)
+      when "list"
+        Annex::List.new(@env, options)
+      end
+      env.info("Executing #{options[:command]}", :command)
+      command.execute
+      exit_code
+    end
+
+    private
+
+    def env
+      @env
+    end
+
+    def parse(argv)
+      # Global option parser
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: annex [-v] [-h] command [<args>]"
+        opts.separator ""
+        opts.separator "Available commands: "
+        opts.separator ""
+
+        COMMANDS.each do |c| opts.separator "    #{c}" end
+
+        opts.separator ""
+        opts.separator "Global options:"
+        opts.separator ""
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          env.info opts
+          return
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          env.info "annex version #{Annex::VERSION}"
+          return
+        end
+      end
+
+      # If there were no options then we show the usage and exit
+      if argv.nil? || argv.length == 0
+        env.info parser
+        return
+      end
+
+      # Grab the first arg, and setup the command options hash
+      options = {:command => argv.shift}
+
+      # Verify the commands
+      parser.order!([options[:command]]) do |unknown|
+        next if COMMANDS.include?(unknown)
+        env.error "Unknown command #{unknown.inspect}"
+        env.info opts
+        return
+      end
+
+      # Create a command specific parser
+      parser = case options[:command]
+      when "provision"
+        OptionParser.new do |opts|
+          opts.banner = "Usage: annex provision <args>"
+          opts.on("-r ROLE", "--role ROLE", "Specify the role for the server you are provisioning") do |role|
+            options[:role] = role
+          end
+          opts.on("-e ENVIRONMENT", "--environment ENVIRONMENT", "Specify the environment for the server you are provisioning") do |environment|
+            options[:environment] = environment
+          end
+        end
+      when "list"
+        OptionParser.new do |opts|
+          opts.banner = "Usage: annex list <args>"
+          opts.on("-r ROLE", "--role ROLE", "List all servers matching the specified role") do |role|
+            options[:role] = role
+          end
+          opts.on("-e ENVIRONMENT", "--environment ENVIRONMENT", "List all servers in the specified environment") do |environment|
+            options[:environment] = environment
+          end
+          opts.on("-a", "--all", "List all servers in all environments") do
+            options[:all] = true
+          end
+        end
+      end
+
+      # If there were no command options then we show the usage and exit
+      if argv.length == 0
+        env.info parser
+        return
+      end
+
+      # Verify the commands
+      parser.parse!(argv) do |unknown|
+        env.error "Unknown option for #{options[:command]} command: #{unknown.inspect}"
+        env.info opts
+        return
+      end
+
+      # Send back the parsed options
+      options
+    end
+  end
+end

data/lib/annex/command.rb

@@ -0,0 +1,46 @@
+require 'fog'
+
+# Need some better logging
+require 'mixins/fog'
+
+module Annex
+  class Command
+    def initialize(env, options)
+      @env = env
+      @options = options
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+
+    protected
+
+    def template(name, template_binding=nil)
+      content = File.read(File.join(File.expand_path(File.dirname(__FILE__)),"..","..","templates","#{name}.erb")) rescue nil
+      erb = ERB.new(content)
+      erb.result(template_binding || binding)
+    end
+
+    def connection
+      @connection = Fog::Compute.new({
+        :provider => 'AWS',
+        :region => @env.config['amazon']['region'] || 'us-east-1',
+        :aws_access_key_id => @env.config['amazon']['access_key_id'],
+        :aws_secret_access_key => @env.config['amazon']['secret_access_key']
+      })
+    end
+
+    def servers
+      @servers ||= connection.servers.all
+    end
+
+    def role
+      @role ||= @options[:role]
+    end
+
+    def environment
+      @environment ||= @options[:environment]
+    end
+  end
+end

data/lib/annex/environment.rb

@@ -0,0 +1,83 @@
+require 'fileutils'
+require 'pathname'
+
+module Annex
+  # Represents an Annex environment. The basic annex environment contains
+  # a config/settings.yml file defining the server cluster.
+  class Environment
+
+    # The `cwd` that this environment represents
+    attr_reader :cwd
+
+    # Initializes a new environment with the given options. The options
+    # is a hash where the main available key is `cwd`, which defines the
+    # location of the environment. If `cwd` is nil, then it defaults
+    # to the `Dir.pwd` (which is the cwd of the executing process).
+    def initialize(opts=nil)
+      opts = {
+        :cwd => nil,
+        :windows => false,
+        :supports_colors => true,
+        :no_colors => false
+      }.merge(opts || {})
+
+      # Set the default working directory
+      opts[:cwd] ||= ENV["ANNEX_CWD"] if ENV.has_key?("ANNEX_CWD")
+      opts[:cwd] ||= Dir.pwd
+      opts[:cwd] = Pathname.new(opts[:cwd])
+      raise Errors::AnnexError.new("Unknown current working directory") if !opts[:cwd].directory?
+
+      # Set instance variables for all the configuration parameters.
+      @cwd = opts[:cwd]
+      @colorize = opts[:supports_colors] || !opts[:no_colors]
+    end
+
+    # Return a human-friendly string for pretty printed or inspected
+    # instances.
+    #
+    # @return [String]
+    def inspect
+      "#<#{self.class}: #{@cwd}>"
+    end
+
+    # Makes a call to the CLI with the given arguments as if they
+    # came from the real command line (sometimes they do!). An example:
+    #
+    #     env.cli("provision", "--role", "app", "--environment", "staging")
+    #
+    def cli(*args)
+      CLI.new(args.flatten, self).execute
+    end
+
+    # The configuration object represented by this environment. This
+    # will trigger the environment to load if it hasn't loaded yet.
+    #
+    # @return [hash]
+    def config
+      @config ||= YAML::load_file(File.join(@cwd, "config", "settings.yml"))
+    end
+
+    # Output a message, formatted if we support colors
+    def info(message, level=:default)
+      $stdout.puts colorize(message, level)
+    end
+
+    # Output a message, formatted if we support colors
+    def error(message)
+      $stderr.puts colorize(message, :error)
+    end
+
+    private
+
+    def colorize(message, level=:info)
+      # Terminal colors
+      colors = {
+        :error   => "\e[31m", # red
+        :info    => "\e[32m", # green
+        :command => "\e[33m", # yellow
+        :notice  => "\e[34m"  # blue
+      }
+      @colorize ? "#{colors[level]}#{message}\e[0m" : message
+    end
+  end
+end

data/lib/annex/errors.rb

@@ -0,0 +1,6 @@
+module Annex
+  module Errors
+    class AnnexError < StandardError
+    end
+  end
+end

data/lib/annex/list.rb

@@ -0,0 +1,20 @@
+module Annex
+  class List < Command
+    def execute
+      which = servers.select do |server|
+        name_tag = server.tags["Name"]
+        name_tag = name_tag.gsub(/-i-[0-9a-f]+$/, '') rescue ''
+
+        choose = server.state == "running"
+        choose = choose && name_tag =~ /^#{role}/ if role
+        choose = choose && name_tag =~ /#{environment}$/ if environment
+        choose
+      end
+
+      which.each do |server|
+        @env.info(server.tags["Name"], :info)
+        @env.info("  #{server.dns_name}\n  Public: #{server.public_ip_address}\n  Private: #{server.private_ip_address}\n", :notice)
+      end
+    end
+  end
+end

data/lib/annex/provision.rb

@@ -0,0 +1,237 @@
+require 'erb'
+require 'json'
+require 'tempfile'
+
+module Annex
+  class Provision < Command
+    def execute
+      if !role && !environment
+        @env.info("Sorry, you must include the role and the environment when provisioning", :error)
+        return
+      end
+
+      begin
+        # Try to determine the environment
+        write_environment
+
+        which = servers.select do |server|
+          name_tag = server.tags["Name"]
+          name_tag = name_tag.gsub(/-i-[0-9a-f]+$/, '') rescue ''
+
+          choose = server.state == "running"
+          choose = choose && name_tag =~ /^#{role}/ if role
+          choose = choose && name_tag =~ /#{environment}$/ if environment
+          choose
+        end
+
+        msg = "We have #{which.length} servers"
+        msg << " for the #{role} role"
+        msg << " in the environment #{environment}"
+        @env.info(msg, :info)
+
+        count = @env.config['roles'][role]['count']
+        @env.info("We should have #{count}", :info)
+
+        # Try to be graceful
+        Thread.abort_on_exception = false
+        threads = []
+
+        # For each server we do have, update
+        which.each do |server|
+          threads << update(server, @env.config['users']['update']) unless ENV['SKIP_UPDATE']
+        end
+
+        # For each server we need, bootstrap
+        (count - which.length).times do
+          image = @env.config['roles'][role]['image']
+          kind = @env.config['amazon']['images'][image]
+          threads << bootstrap(connection, kind['image_id'], kind['flavor_id'], kind['az_id'], @env.config['users']['bootstrap'])
+        end
+
+        threads.each do |thr|
+          thr.join unless ENV['SYNC']
+        end
+
+      ensure
+        cleanup_environment
+      end
+    end
+
+    private
+
+    def ruby_script
+      if @env.config['roles'][role]['ruby'] == "package"
+        template("ruby-apt.sh")
+      elsif @env.config['roles'][role]['ruby'] == "1.9.3"
+        template("ruby-1.9.3.sh")
+      else
+        template("ruby-ree.sh")
+      end
+    end
+
+    # Bootstrap the environment with chef to handle chef-roles
+    def bootstrap_script(options={})
+      template_binding = OpenStruct.new(options)
+      template("bootstrap.sh", template_binding.instance_eval { binding })
+    end
+
+    # Bootstrap the environment with chef to handle chef-roles
+    def update_script(options={})
+      template_binding = OpenStruct.new(options)
+      template("update.sh", template_binding.instance_eval { binding })
+    end
+
+    def bootstrap(connection, image_id, flavor_id, az_id, user)
+      thr = Thread.new(connection, image_id, flavor_id, az_id, user) do |_connection, _image_id, _flavor_id, _az_id, _user|
+        sleep 1
+
+        @env.info("Bootstrapping #{role} server...", :info)
+
+        begin
+          # Build the server from the base AMI
+          server = _connection.servers.bootstrap({
+            :private_key_path => '~/.ssh/id_rsa',
+            :public_key_path => '~/.ssh/id_rsa.pub',
+            :availability_zone => _az_id,
+            :username => _user,
+            :image_id => _image_id,
+            :flavor_id => _flavor_id
+          })
+
+          node_name = "#{role}-#{environment}-#{server.identity}"
+
+          # Add the tags
+          _connection.tags.create(
+            :resource_id => server.identity,
+            :key => 'Name',
+            :value => node_name)
+        rescue Exception => e
+          @env.error("Error for #{server.id} (#{e.message})\n\n#{e.backtrace}", :error)
+          return
+        end
+
+        scp_options = { :forward_agent => true }
+        scp = Fog::SCP.new(server.public_ip_address, server.username, scp_options)
+        scp.upload(@envfile.path.to_s, "#{environment}.json")
+
+        ssh_options = { :forward_agent => true }
+        ssh = Fog::SSH.new(server.public_ip_address, server.username, ssh_options)
+
+        begin
+          return if _image_id == "windows"
+          script = bootstrap_script({
+            :environment => environment,
+            :node_name => node_name,
+            :role => role,
+            :user => @env.config['users']['bootstrap'],
+            :ruby_script => ruby_script,
+            :repository => @env.config['repository']
+          })
+          script.split(/\n/).each do |cmd|
+            next if cmd == ''
+            @env.info("")
+            @env.info("Running command:", :info)
+            @env.info("")
+            @env.info("  #{cmd}", :command)
+            ssh.run(cmd)
+          end
+        rescue Exception => e
+          @env.error("Error for #{server.id} (#{e.message})\n\n#{e.backtrace}", :error)
+        end
+
+        begin
+          @env.info("")
+          @env.info("Done", :info)
+          @env.info("  #{server.dns_name}", :notice)
+          @env.info("  Public: #{server.public_ip_address}", :notice)
+          @env.info("  Private: #{server.private_ip_address}", :notice)
+        rescue
+        end
+      end
+      thr.join if ENV['SYNC']
+      thr
+    end
+
+    def update(server, user)
+      thr = Thread.new(server, user) do |_server, _user|
+        sleep 1
+
+        @env.info("Updating #{_server.public_ip_address} (#{_server.id})\n", :info)
+
+        scp_options = { :forward_agent => true }
+        scp = Fog::SCP.new(_server.public_ip_address, _user, scp_options)
+        scp.upload(@envfile.path.to_s, "#{environment}.json")
+
+        ssh_options = { :forward_agent => true }
+        ssh = Fog::SSH.new(_server.public_ip_address, _user, ssh_options)
+
+        node_name = "#{role}-#{environment}-#{_server.identity}"
+
+        begin
+          script = update_script({
+            :environment => environment,
+            :node_name => node_name,
+            :role => role,
+            :user => @env.config['users']['update']
+          })
+          script.split(/\n/).each do |cmd|
+            next if cmd == ''
+            @env.info("")
+            @env.info("Running command:", :info)
+            @env.info("")
+            @env.info("  #{cmd}", :command)
+            ssh.run(cmd)
+          end
+        rescue Exception => e
+          @env.error("Error for #{_server.id} (#{e.message})\n\n#{e.backtrace}", :error)
+        end
+
+        begin
+          @env.info("")
+          @env.info("Done", :info)
+          @env.info("  #{_server.dns_name}", :notice)
+          @env.info("  Public: #{_server.public_ip_address}", :notice)
+          @env.info("  Private: #{_server.private_ip_address}", :notice)
+        rescue
+        end
+      end
+      thr.join if ENV['SYNC']
+      thr
+    end
+
+    def write_environment
+      @nodes = []
+      servers.each do |server|
+        next unless server.state == "running"
+        next unless server.tags["Name"] && server.tags["Name"] != ''
+
+        role = server.tags["Name"].gsub(/-.*/, '')
+        env = server.tags["Name"].gsub(/^[^-]+-/, '').gsub(/-.*/, '')
+        next unless env == environment
+
+        @nodes << {
+          :name => server.tags["Name"],
+          :role => role,
+          :environment => env,
+          :public_fqdn => server.dns_name,
+          :public_ip => server.public_ip_address,
+          :private_ip => server.private_ip_address
+        }
+      end
+      @nodes
+
+      @envfile = Tempfile.new("annex-#{environment}.json")
+      @envfile.puts({:id => environment, :nodes => @nodes}.to_json)
+      @envfile.flush
+      @envfile
+    end
+
+    def cleanup_environment
+      return unless @envfile
+      @envfile.close
+      @envfile.unlink
+      @envfile = nil
+    end
+
+  end
+end

data/lib/annex/version.rb

@@ -0,0 +1,3 @@
+module Annex
+  VERSION = "0.0.2"
+end

data/lib/mixins/fog.rb

@@ -0,0 +1,69 @@
+module Fog
+  module SSH
+    class Real
+      def run(commands)
+        commands = [*commands]
+        results  = []
+        begin
+          Net::SSH.start(@address, @username, @options) do |ssh|
+            commands.each do |command|
+              result = Result.new(command)
+              ssh.open_channel do |ssh_channel|
+                ssh_channel.request_pty
+                ssh_channel.exec(command) do |channel, success|
+                  unless success
+                    raise "Could not execute command: #{command.inspect}"
+                  end
+
+                  channel.on_data do |ch, data|
+                    result.stdout << handle_data(channel, data)
+                  end
+
+                  channel.on_extended_data do |ch, type, data|
+                    next unless type == 1
+                    result.stderr << handle_error(channel, data)
+                  end
+
+                  channel.on_request('exit-status') do |ch, data|
+                    result.status = data.read_long
+                  end
+
+                  channel.on_request('exit-signal') do |ch, data|
+                    result.status = 255
+                  end
+                end
+              end
+              ssh.loop
+              results << result
+            end
+          end
+        rescue Net::SSH::HostKeyMismatch => exception
+          exception.remember_host!
+          sleep 0.2
+          retry
+        end
+        results
+      end
+
+      def handle_data(channel, data)
+        data
+      end
+
+      def handle_error(channel, error)
+        error
+      end
+    end
+
+    class Real
+      def handle_data(channel, data)
+        puts data
+        data
+      end
+
+      def handle_error(channel, error)
+        puts error.red
+        error
+      end
+    end
+  end
+end

data/templates/bootstrap.sh.erb

@@ -0,0 +1,24 @@
+sudo apt-get update
+sudo apt-get -y install ssh git-core wget curl build-essential clang bison openssl zlib1g libxslt1.1 libssl-dev libxslt1-dev libxml2 libffi-dev libyaml-dev libxslt-dev autoconf libc6-dev libreadline6-dev zlib1g-dev libcurl4-openssl-dev
+
+<%= ruby_script %>
+
+sudo gem install rake --no-ri --no-rdoc
+sudo gem install slimgems --no-ri --no-rdoc
+sudo gem install chef -v 10.20.0 --no-ri --no-rdoc
+
+sudo mkdir -p /var/chef-solo
+sudo chown <%= user %> /var/chef-solo
+
+echo "github.com,207.97.227.239 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==" >> ~/.ssh/known_hosts
+
+git clone <%= repository %> /var/chef-solo/cookbooks
+cp <%= environment %>.json /var/chef-solo/cookbooks/data_bags/environments/
+
+sudo mkdir -p /etc/chef
+sudo chown <%= user %> /etc/chef
+cp /var/chef-solo/cookbooks/solo.rb /etc/chef
+echo 'node_name "<%= node_name %>"' >> /etc/chef/solo.rb
+echo '{ "run_list": ["role[<%= role %>]"]}' > /etc/chef/dna.json
+
+sudo chef-solo -c /etc/chef/solo.rb -j /etc/chef/dna.json

data/templates/ruby-1.9.3.sh.erb

@@ -0,0 +1,5 @@
+wget http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.3-p0.tar.gz
+tar -xzf ruby-1.9.3-p0.tar.gz 2>&1
+cd ruby-1.9.3-p0 && ./configure --prefix=/usr/local 2>&1 \
+&& make 2>&1 \
+&& sudo make install 2>&1

data/templates/ruby-apt.sh.erb

@@ -0,0 +1,5 @@
+sudo apt-get -y install ruby ruby-dev libopenssl-ruby1.8 irb ri rdoc
+wget http://production.cf.rubygems.org/rubygems/rubygems-1.3.7.tgz
+tar xvzf rubygems-1.3.7.tgz
+cd rubygems-1.3.7 && sudo ruby setup.rb
+sudo ln -s /usr/bin/gem1.8 /usr/bin/gem

data/templates/ruby-ree.sh.erb

@@ -0,0 +1,2 @@
+wget http://rubyenterpriseedition.googlecode.com/files/ruby-enterprise_1.8.7-2011.03_amd64_ubuntu10.04.deb
+sudo dpkg -i ruby-enterprise_1.8.7-2011.03_amd64_ubuntu10.04.deb

data/templates/update.sh.erb

@@ -0,0 +1,10 @@
+sudo chown -R <%= user %>:<%= user %> /var/chef-solo
+sudo chown -R <%= user %>:<%= user %> /etc/chef
+cd /var/chef-solo/cookbooks && git pull origin master
+cp <%= environment %>.json /var/chef-solo/cookbooks/data_bags/environments
+
+cp /var/chef-solo/cookbooks/solo.rb /etc/chef
+echo 'node_name "<%= node_name %>"' >> /etc/chef/solo.rb
+echo '{ "run_list": ["role[<%= role %>]"]}' > /etc/chef/dna.json
+
+sudo chef-solo -c /etc/chef/solo.rb -j /etc/chef/dna.json

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: annex
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jeff Rafter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-06-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Annex leverages chef-solo to allow you to provision and update mutliple servers by looking up network topology on the fly utilizing a distributed repository to manage recipes"
+email: 
+- jeffrafter@gmail.com
+executables: 
+- annex
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- annex.gemspec
+- bin/annex
+- config/settings.yml.example
+- lib/annex.rb
+- lib/annex/cli.rb
+- lib/annex/command.rb
+- lib/annex/environment.rb
+- lib/annex/errors.rb
+- lib/annex/list.rb
+- lib/annex/provision.rb
+- lib/annex/version.rb
+- lib/mixins/fog.rb
+- templates/bootstrap.sh.erb
+- templates/ruby-1.9.3.sh.erb
+- templates/ruby-apt.sh.erb
+- templates/ruby-ree.sh.erb
+- templates/update.sh.erb
+has_rdoc: true
+homepage: http://github.com/jeffrafter/annex
+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: annex
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Quickly provision servers using chef-solo and no central server.
+test_files: []
+