bum 0.0.1

data/README

@@ -0,0 +1,12 @@
+To make a new base VM:
+
+1) Install your OS (only tested with Ubuntu 10.04 64-bit)
+2) Setup a user with a password that you don't mind hardcoding in your Bumfile
+3) Make sure that user has no-password sudo access
+4) sudo apt-get install ruby1.8 ruby1.8-dev libopenssl-ruby rubygems ssh
+5) sudo gem install chef
+6) Delete /etc/udev/rules.d/70-persistent-net.whatever
+7) Shut down VM
+8) Remove all *.lck files from inside the VM's vmwarevm folder
+
+DONE!

data/bin/bum

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+require 'bum'
+
+class CLI < Thor
+  desc "destroy [NODENAME]", "Completely destroy a VM"
+  def destroy(node_name=nil)
+    bum = Bum.new
+    if node_name
+      bum.destroy(node_name)
+    else
+      bum.destroy_all
+    end
+  end
+
+  desc "start [NODENAME]", "Start a VM"
+  def start(node_name=nil)
+    bum = Bum.new
+    if node_name
+      bum.start(node_name)
+    else
+      bum.start_all
+    end
+  end
+
+  desc "stop [NODENAME]", "Stop a VM"
+  def stop(node_name=nil)
+    bum = Bum.new
+    if node_name
+      bum.stop(node_name)
+    else
+      bum.stop_all
+    end
+  end
+
+  desc "setup [NODENAME]", "Refresh configs and run Chef on a VM"
+  def setup(node_name=nil)
+    bum = Bum.new
+    if node_name
+      bum.setup(node_name)
+    else
+      bum.setup_all
+    end
+  end
+
+  desc 'write_hosts', 'Write out a new /etc/hosts file'
+  def write_hosts
+    bum = Bum.new
+    bum.write_hosts
+  end
+end
+
+CLI.start

data/lib/bum.rb

@@ -0,0 +1,380 @@
+require 'rubygems'
+require 'net/ssh'
+require 'net/scp'
+require 'json'
+
+require 'fileutils'
+require 'erb'
+require 'ostruct'
+
+require 'vmx'
+require 'dhcpd'
+require 'hosts'
+
+class Bum
+  DEFAULT_BUMFILE = './Bumfile'
+  DEFAULT_VM_PATH = File.expand_path('~/Documents/Virtual Machines.localized/')
+
+  VMWARE_PATH = '/Library/Application Support/VMware Fusion'
+  DHCPD_CONF_PATH = "#{VMWARE_PATH}/vmnet8/dhcpd.conf"
+
+  def initialize(bumfile=DEFAULT_BUMFILE)
+    @bum_config = Bum::Config.new(DEFAULT_BUMFILE)
+  end
+
+  def bootstrap
+    vmx = template_vmx
+    vmx.data['sharedFolder0.hostPath'] = File.expand_path('~')
+    vmx.data['sharedFolder0.guestName'] = 'host_home'
+    vmx.save
+  end
+
+  def create(node_name)
+    node_config = get_node_config(node_name)
+
+    raise "VM already exists!" if vm_exists?(node_name)
+
+    puts "Cloning template..."
+    clone_template node_name
+
+    puts "Updating machine configuration..."
+    mac = generate_mac
+    uuid = generate_uuid
+
+    vmx = node_vmx(node_name)
+    vmx.data['displayName'] = node_name
+    vmx.data['memsize'] = node_config.config[:ram] || @bum_config.config[:default_ram] || 512
+    vmx.data['numvcpus'] = node_config.config[:cpus] || @bum_config.config[:default_cpus] || 1
+    vmx.data['ethernet0.address'] = mac
+    vmx.data['uuid.bios'] = uuid
+    vmx.data['uuid.location'] = uuid
+    vmx.save
+
+    dhcpd = DHCPD.new(DHCPD_CONF_PATH)
+    dhcpd.config[node_name] = {
+      'hardware ethernet' => mac,
+      'fixed-address' => node_config.config[:ip]
+    }
+    dhcpd.save
+
+    puts "Restarting dhcpd..."
+    dhcpd.restart
+
+    puts "Starting..."
+    start_node(node_name)
+
+    setup(node_name)
+  end
+
+  def setup(node_name)
+    node_config = get_node_config(node_name)
+
+    puts "Setting up #{node_name}..."
+
+    client_erb = ERB.new(File.read('client.rb.erb'))
+    client_rb_data = client_erb.result(OpenStruct.new(:config => @bum_config.config, :node_config => node_config).send(:binding))
+    tmp_client_rb_path = ".tmp.#{node_name}.client.rb"
+    File.open(tmp_client_rb_path,'w') do |f|
+      f.puts client_rb_data
+    end
+
+    chef_attribs = {
+      :run_list => @bum_config.config[:default_run_list] + node_config.config[:run_list],
+      :ip => {
+        :private => node_config.config[:ip],
+        :private_netmask => '255.255.255.0'
+      }
+    }.merge(@bum_config.config[:chef_options]).merge(node_config.config[:chef_options])
+
+    puts "Uploading Chef files..."
+    Net::SCP.start node_config.config[:ip], @bum_config.config[:ssh_user], :password => @bum_config.config[:ssh_password] do |scp|
+      scp.upload! tmp_client_rb_path, "client.rb"
+      scp.upload! @bum_config.config[:validation_key_path], "validation.pem"
+      scp.upload! StringIO.new(chef_attribs.to_json), "client-config.json"
+    end
+
+    FileUtils.rm(tmp_client_rb_path)
+
+    enable_shared_folders node_name
+    @bum_config.config[:shares].each do |share_name, guest_path, host_path, options|
+      cmd "mkdir -p #{host_path}"
+      share_folder node_name, share_name, host_path
+    end
+
+    puts "Connecting over SSH..."
+    Net::SSH.start node_config.config[:ip], @bum_config.config[:ssh_user], :password => @bum_config.config[:ssh_password] do |ssh|
+      ssh_exec ssh, "sudo hostname #{node_name}"
+      ssh_exec ssh, "sudo mkdir /etc/chef"
+
+      @bum_config.config[:shares].each do |share_name, guest_path, host_path, options|
+        ssh_exec ssh, "sudo mkdir -p #{File.dirname(guest_path)} && sudo ln -sf /mnt/hgfs/#{share_name} #{guest_path}"
+      end
+
+      ssh_exec ssh, "sudo mv client.rb /etc/chef/"
+      ssh_exec ssh, "sudo mv validation.pem /etc/chef/"
+      ssh_exec ssh, "sudo mv client-config.json /etc/chef/"
+
+      ssh.exec! "sudo /var/lib/gems/1.8/bin/chef-client" do |channel, stream, data|
+        print data
+      end
+    end
+  end
+  
+  def destroy(node_name)
+    node_config = get_node_config(node_name)
+
+    if vm_exists?(node_name)
+      stop_node(node_name)
+
+      puts "Removing #{node_name} from Chef..."
+      `knife node delete #{node_name} -y`
+      `knife client delete #{node_name} -y`
+
+      puts "Destroying #{node_name}..."
+      FileUtils.rm_rf(node_name_to_vm_path(node_name))
+    else
+      puts "#{node_name} hasn't even been created yet, thusly you can't destroy it!"
+    end
+  end
+
+  def stop(node_name)
+    node_config = get_node_config(node_name)
+
+    if vm_running?(node_name)
+      puts "Stopping #{node_name}..."
+      stop_node(node_name)
+    else
+      puts "wtf, #{node_name} is not running."
+    end
+  end
+
+  def start(node_name)
+    node_config = get_node_config(node_name)
+
+    if vm_running?(node_name)
+      puts "Dude, #{node_name} is already running!"
+    elsif vm_exists?(node_name)
+      puts "Starting #{node_name}..."
+      start_node node_name
+    else
+      puts "Generating, then starting #{node_name}..."
+      create node_name
+    end
+  end
+
+  def write_hosts
+    puts "Writing /etc/hosts file..."
+    hosts = Hosts.new
+    @bum_config.config[:nodes].each do |node|
+      hosts.config[node.config[:ip]] = node.name
+    end
+    hosts.save
+  end
+
+  
+  def start_all
+    puts "Starting all nodes..."
+    @bum_config.config[:nodes].each { |n| start(n.name) }
+  end
+
+  def stop_all
+    puts "Stopping all nodes..."
+    @bum_config.config[:nodes].each { |n| stop(n.name) }
+  end
+
+  def destroy_all
+    puts "Destroying all nodes..."
+    @bum_config.config[:nodes].each { |n| destroy(n.name) }
+  end
+
+  def setup_all
+    puts "Setting up all nodes..."
+    @bum_config.config[:nodes].each { |n| setup(n.name) }
+  end
+
+  private
+
+  def cmd(*args)
+    puts ["local>", *args].join(" ")
+    system *args
+  end
+
+  def ssh_exec(ssh, cmd)
+    puts "ssh> #{cmd}"
+    print ssh.exec!(cmd)
+  end
+
+  def enable_shared_folders(node_name)
+    cmd "'#{VMWARE_PATH}/vmrun' enableSharedFolders '#{node_name_to_vmx(node_name)}'"
+  end
+
+  def share_folder(node_name, share_name, path)
+    cmd "'#{VMWARE_PATH}/vmrun' addSharedFolder '#{node_name_to_vmx(node_name)}' '#{share_name}' '#{path}'"
+  end
+
+  def get_node_config(node_name)
+    node_config = @bum_config.get_node(node_name)
+    raise "Alas, I don't know about a node named #{node_name.inspect}..." unless node_config
+    node_config
+  end
+
+  def vm_exists?(node_name)
+    File.exists? node_name_to_vm_path(node_name)
+  end
+
+  def vm_running?(node_name)
+    `'#{VMWARE_PATH}/vmrun' list`.include?("#{node_name}.vmwarevm")
+  end
+
+  def clone_template(node_name)
+    FileUtils.cp_r(template_vm_path, node_name_to_vm_path(node_name))
+  end
+
+  def template_vmx
+    @template_vmx ||= VMX.new(@bum_config.config[:vmx])
+  end
+
+  def node_vmx(node_name)
+    VMX.new(node_name_to_vmx(node_name))
+  end
+
+  def start_node(node_name)
+    cmd "'#{VMWARE_PATH}/vmrun' start '#{node_name_to_vmx(node_name)}' nogui  >>vmware.log 2>&1"
+  end
+
+  def stop_node(node_name)
+    cmd "'#{VMWARE_PATH}/vmrun' stop '#{node_name_to_vmx(node_name)}' >>vmware.log 2>&1"
+  end
+
+  def generate_mac
+    "00:50:56:" + 3.times.map { ("%2s" % rand(256).to_s(16)).gsub(' ','0') }.join(':').upcase
+  end
+
+  # not actually universal - doesn't fucking matter
+  def generate_uuid
+    2.times.map {
+      8.times.map {
+        ("%2s" % rand(256).to_s(16)).gsub(' ','0')
+      }.join(' ')
+    }.join('-')
+  end
+
+  def node_name_to_vmx(node_name)
+    Dir[File.join(node_name_to_vm_path(node_name), '*.vmx')][0]
+  end
+
+  def node_name_to_vm_path(node_name)
+    File.join(DEFAULT_VM_PATH, "#{node_name}.vmwarevm")
+  end
+
+  def template_vm_path
+    File.dirname(@bum_config.config[:vmx])
+  end
+
+  class Config
+    attr_reader :config
+
+    def initialize(bumfile)
+      @config = {
+        :nodes => [],
+        :ssh_user => 'dev',
+        :ssh_password => 'password',
+        :shares => [],
+        :suffix => ''
+      }
+      instance_eval File.read(bumfile)
+    end
+
+    def get_node(node_name)
+      @config[:nodes].detect { |n| n.name == node_name }
+    end
+
+
+    def ssh_user(user)
+      @config[:ssh_user] = user
+    end
+
+    def ssh_password(pass)
+      @config[:ssh_password] = pass
+    end
+
+    def vmx(vmx_file)
+      @config[:vmx] = File.expand_path(vmx_file)
+    end
+
+    def node(name, &block)
+      @config[:nodes] << Node.new(name + @config[:suffix], name, &block)
+    end
+
+    def ram(megabytes)
+      @config[:default_ram] = megabytes
+    end
+
+    def cpus(count)
+      @config[:default_cpus] = count
+    end
+
+    def chef_server_url(url)
+      @config[:chef_server_url] = url
+    end
+
+    def validation_key_path(path)
+      @config[:validation_key_path] = File.expand_path(path)
+    end
+
+    def validation_client_name(name)
+      @config[:validation_client_name] = name
+    end
+
+    def chef_environment(env)
+      @config[:chef_environment] = env
+    end
+
+    def chef_options(opts)
+      @config[:chef_options] = opts
+    end
+
+    def default_run_list(list)
+      @config[:default_run_list] = list
+    end
+
+    def share(share_name, guest_path, host_path, options={})
+      @config[:shares] << [share_name, guest_path, File.expand_path(host_path), options]
+    end
+
+    def node_suffix(suffix)
+      @config[:suffix] = suffix
+    end
+
+    class Node
+      attr_reader :name, :pretty_name, :config
+
+      def initialize(name, pretty_name, &block)
+        @name = name
+        @pretty_name = pretty_name
+        @config = {}
+        instance_eval &block
+      end
+
+      def run_list(*recipes)
+        @config[:run_list] = recipes
+      end
+
+      def ip(addr)
+        @config[:ip] = addr
+      end
+
+      def chef_options(options)
+        @config[:chef_options] = options
+      end
+
+      def ram(megabytes)
+        @config[:ram] = megabytes
+      end
+
+      def cpus(count)
+        @config[:cpus] = count
+      end
+    end
+  end
+end

data/lib/client.rb.erb

@@ -0,0 +1,7 @@
+# Managed by Bum
+
+node_name              "<%= node_config.name %>"
+chef_server_url        "<%= config[:chef_server_url] %>"
+validation_client_name "<%= config[:validation_client_name] %>"
+environment            "<%= config[:chef_environment] %>"
+json_attribs           "/etc/chef/client-config.json"

data/lib/dhcpd.rb

@@ -0,0 +1,84 @@
+class DHCPD
+  attr_reader :config
+
+  def initialize(conf_path)
+    @conf_path = conf_path
+    @preamble = ''
+    @postamble = ''
+    @config = {}
+
+    parse
+  end
+
+  def save
+    tmp_path = '.tmp.dhcpd.conf'
+    File.open(tmp_path, 'w') do |f|
+      f.write @preamble
+      f.puts BEGIN_BUM
+
+      @config.each do |host, host_config|
+        f.puts "host #{host} {"
+        host_config.each do |key, value|
+          f.puts "\t#{key} #{value};"
+        end
+        f.puts "}"
+      end
+
+      f.puts END_BUM
+      f.write @postamble
+    end
+
+    system 'sudo', 'mv', tmp_path, @conf_path
+  end
+
+  def restart
+    system 'sudo "/Library/Application Support/VMware Fusion/boot.sh" --restart >>vmware.log 2>&1'
+  end
+
+
+  private
+
+  BEGIN_BUM = "#### BEGIN BUM ####"
+  END_BUM = "#### END BUM ####"
+
+  def parse
+    state = :preamble
+    host = nil
+
+    File.open(@conf_path).each_line do |rawline|
+      line = rawline.strip
+
+      case state
+      when :preamble
+        if line == BEGIN_BUM
+          state = :outside_host
+        else
+          @preamble << rawline
+        end
+
+      when :outside_host
+        next unless line =~ /^host .* \{$/
+        words = line.split(' ').map { |x| x.strip }
+        host = words[1]
+        @config[host] = {}
+        state = :inside_host
+
+      when :inside_host
+        next if line.size == 0 || line.strip =~ /^#/
+        if line == '}'
+          state = :outside_host
+          host = nil
+        elsif line == END_BUM
+          state = :postamble
+        else
+          parts = line.chomp(';').split(' ')
+          @config[host][parts[0..-2].join(' ')] = parts[-1]
+        end
+
+      when :postamble
+        @postamble << rawline
+      end
+    end
+
+  end
+end

data/lib/hosts.rb

@@ -0,0 +1,61 @@
+# Class for parsing and writing /etc/hosts file
+
+class Hosts
+  def initialize
+    @preamble = ""
+    @postamble = ""
+    @config = {}
+
+    parse
+  end
+
+  attr_reader :config
+
+  def save
+    File.open('.tmp.hosts','w') do |f|
+      f.write @preamble
+      f.puts BEGIN_LINE
+
+      @config.each do |ip, host|
+        f.puts "#{ip}\t#{host}"
+      end
+
+      f.puts END_LINE
+      f.write @postamble
+    end
+    system "sudo mv .tmp.hosts /etc/hosts"
+  end
+
+  private
+
+  BEGIN_LINE = "#### BEGIN BUM ####"
+  END_LINE = "#### END BUM ####"
+
+  def parse
+    state = :preamble
+
+    File.open('/etc/hosts').each_line do |line|
+      case state
+      when :preamble
+        if line.include? BEGIN_LINE
+          state = :bum
+        else
+          @preamble << line
+        end
+      when :bum
+        if line.include? END_LINE
+          state = :postamble
+        else
+          if line.strip =~ /^#/
+            # skip
+          else
+            ip, host = line.split(/\s+/)
+            @config[ip] = host
+          end
+        end
+      when :postamble
+        @postamble << line
+      end
+    end
+  end
+end

data/lib/vmx.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+class VMX
+  attr_reader :data
+
+  def initialize(filename)
+    @filename = filename
+    @data = {}
+
+    File.open(filename).each_line do |line|
+      key, value = line.split('=', 2)
+      @data[key.strip] = eval(value)
+    end
+  end
+
+  def save(filename=@filename)
+    FileUtils.cp(filename, filename + '.bak')
+    File.open(filename, 'w') do |f|
+      @data.sort_by { |(k,v)| k }.each do |(k,v)|
+        f.puts "#{k} = #{v.to_s.inspect}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: bum
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tyler McMullen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  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: net-ssh
+  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
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Inspired by Vagrant but much much simpler. Also uses VMware, instead of Virtualbox.
+email: 
+- tyler@fastly.com
+executables: 
+- bum
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/bum
+- lib/bum.rb
+- lib/client.rb.erb
+- lib/dhcpd.rb
+- lib/hosts.rb
+- lib/vmx.rb
+- README
+has_rdoc: true
+homepage: http://github.com/fastly/Bum
+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: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A semi-sane way to manage a multi-vm dev environment
+test_files: []
+