bum 0.0.4 → 0.0.12

data/README

@@ -1,12 +0,0 @@
-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

@@ -1,55 +1,22 @@
 #!/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
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-  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
+require 'rubygems'
+require 'net/dns/mdns-sd'
 
-  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
+master_address = nil
+puts 'Looking for the master node...'
+service = Net::DNS::MDNSSD.browse('_demo._tcp') { |r|
+  puts "Found #{r.name}!"
+  master_address = r.name
+}
+sleep 3
 
-  desc 'write_hosts', 'Write out a new /etc/hosts file'
-  def write_hosts
-    bum = Bum.new
-    bum.write_hosts
-  end
+if master_address
+  require 'node'
+  node = Node.new(master_address, 9125)
+  node.run
+else
+  puts "Couldn't find a master node. Dying."
 end
-
-CLI.start

data/bin/bum_master

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'master'
+
+master = Master.new
+master.run
+
+require 'rubygems'
+require 'net/dns/mdns-sd'
+
+record = { 'description' => 'GoGaRuCo Demo!' }
+Net::DNS::MDNSSD.register(Socket.gethostname, '_demo._tcp', 'local', 9125, record) do |reply|
+  p reply
+end
+
+web = MasterWeb.new(master)
+Rack::Handler::Mongrel.run web, :Port => 8000
+

data/lib/app_role.rb

@@ -0,0 +1,83 @@
+require 'role'
+require 'sinatra/base'
+require 'db_crap'
+
+class RailsRole < Role
+  PORT = 9300
+  role 'rails'
+
+  def initialize(manifest)
+    super
+    init_links 'db_write', @manifest['db_write']
+    init_links 'db_read', @manifest['db_read']
+    init_links 'db_peer', @manifest['db_peer']
+  end
+
+  def start
+    # @manifest['db'].each do |db_addr|
+    #  @db_sockets[db_addr] = DemoSocket.connect(db_addr, DbRole::PORT)
+    #end
+
+    start_server
+  end
+
+  def stop
+    @http_server.shutdown
+    # @db_sockets.each { |a,s| s.close }
+  end
+
+  alias :enable :start
+  alias :disable :stop
+
+  private
+
+  def start_server
+    my_app = MyApp.new(@active_links, @manifest)
+
+    trap('INT') do
+      @http_server.shutdown if @http_server
+      exit
+    end
+
+    Thread.new {
+      Rack::Handler::WEBrick.run(my_app, :Port => PORT.to_s) do |server|
+        @http_server = server
+      end
+    }
+  end
+
+  class MyApp < Sinatra::Base
+    def initialize(active_links, manifest)
+      @active_links = active_links
+      @manifest = manifest
+      super()
+    end
+
+    set :public, File.dirname(__FILE__) + '/../public'
+    set :views, File.dirname(__FILE__) + '/../views'
+
+    get '/one' do
+      @list = list
+      erb :one
+    end
+
+    get '/two' do
+      @list = list
+      erb :two
+    end
+
+    post '/' do
+      write request.params['key'], request.params['value']
+      redirect request.params['return_to']
+    end
+
+    get '/ping' do
+      'pong'
+    end
+
+    private
+
+    include DbCrap
+  end
+end
+

data/lib/client.rb

@@ -0,0 +1,104 @@
+require 'thread'
+require 'system_timer'
+
+
+class Client
+  class << self
+    attr_accessor :clients, :client_index
+
+    def remove(client)
+      puts "--- #{client.addr} has disconnected"
+      clients.delete client
+      client_index.delete client.addr
+    end
+
+    def add(client)
+      clients << client
+      client_index[client.addr] = client
+    end
+  end
+
+  Client.clients = []
+  Client.client_index = {}
+
+  attr_reader :name
+
+  def initialize(demo_socket)
+    @socket = demo_socket
+
+    Client.add self
+
+    @lock = Mutex.new
+
+    @outbox = Queue.new
+    @inbox = Queue.new
+
+    @comm_thread = start_comm
+    @pulse_thread = start_heartbeat
+  end
+
+  def lock(&block)
+    @lock.synchronize &block
+  end
+
+  def send(data)
+    @outbox << data
+  end
+
+  def recv
+    SystemTimer.timeout 1 do
+      @inbox.pop
+    end
+  rescue Timeout::Error
+    puts "#{addr} timed out"
+    false
+  end
+
+  def msg(data)
+    lock {
+      send data
+      recv
+    }
+  end
+
+  def addr
+    @socket.addr
+  end
+
+  def hostname
+    @socket.hostname
+  end
+
+  def start_comm
+    Thread.new {
+      loop do
+        msg = @outbox.pop
+        begin
+          @socket.send msg
+          @inbox << @socket.recv
+        rescue DemoSocket::SocketError => e
+          Client.remove(self)
+          @pulse_thread.kill
+          @comm_thread.kill
+        end
+      end
+    }
+  end
+
+  def start_heartbeat
+    client = self
+    Thread.new {
+      loop do
+        response = msg('t' => 'HRT')
+        if response
+          @name = response['name']
+        else
+          Client.remove(self)
+          @comm_thread.kill
+          @pulse_thread.kill
+        end
+        sleep 2
+      end
+    }
+  end
+end

data/lib/db_crap.rb

@@ -0,0 +1,85 @@
+require 'set'
+
+module DbCrap
+  class NoDbConnections < StandardError ; end
+
+  def list
+    if use_peer_dbs?
+      out = []
+      seen = []
+      on_each_peer do |db|
+        db.send('cmd' => 'LIST')
+        new_recs = db.recv
+        new_recs.each do |rec|
+          unless seen.include?(rec['key'])
+            out << rec
+            seen << rec['key']
+          end
+        end
+      end
+      out
+    else
+      db = get_read_db
+      if db
+        db.send('cmd' => 'LIST')
+        db.recv
+      else
+        raise NoDbConnections
+      end
+    end
+  end
+
+  def write(key,value)
+    if use_peer_dbs?
+      db = get_peer_db_for(key)
+    else
+      db = get_write_db
+    end
+    
+    if db
+      db.send 'cmd' => 'PUT', 'key' => request.params['key'], 'value' => request.params['value']
+      db.recv
+    else
+      raise NoDbConnections
+    end
+  rescue Errno::ECONNREFUSED
+    puts "Hm... I couldn't get a connection to a database node."
+  end
+  
+  def get_write_db
+    db_addr = @active_links['db_write'].sort_by { rand }.first
+    DemoSocket.connect(db_addr, DbRole::PORT)
+  end
+  
+  def on_each_peer
+    @active_links['db_peer'].each do |db_addr|
+      begin
+        yield DemoSocket.connect(db_addr, DbRole::PORT)
+      rescue Errno::ECONNREFUSED
+      end
+    end
+  end
+  
+  def get_peer_db_for(key)
+    index = (key.hash % @manifest['db_peer'].size)
+    db_addr = @manifest['db_peer'][index]
+    if @active_links['db_peer'].include?(db_addr)
+      DemoSocket.connect(db_addr, DbRole::PORT)
+    end
+  end
+  
+  def get_read_db
+    addrs = @active_links['db_read'].sort_by { rand }
+    begin
+      db_addr = addrs.pop
+      DemoSocket.connect(db_addr, DbRole::PORT)
+    rescue Errno::ECONNREFUSED
+      retry if addrs.size > 0
+    end
+  end
+  
+  def use_peer_dbs?
+    @manifest['db_peer'] && @manifest['db_peer'].size > 0
+  end
+  
+end

data/lib/db_role.rb

@@ -0,0 +1,107 @@
+require 'role'
+
+class DbRole < Role
+  PORT = 9200
+  include Server
+
+  role 'db'
+
+  def state
+    super.merge('extra' => { 'slave' => @manifest['slave'] })
+  end
+
+  def initialize(manifest)
+    super
+    @queues = Hash.new { |h,k| h[k] = [] }
+    init_links 'slaves', @manifest['slaves'] do |event,addr|
+      case event
+      when 'enable'
+        @queues[addr].each { |msg|
+          begin
+            slave_sock = DemoSocket.connect(addr, PORT)
+            slave_sock.send msg
+            slave_sock.recv
+          rescue Errno::ECONNREFUSED, Errno::ECONNABORTED
+          end
+        }
+      end
+    end
+
+    @data = {
+      'lorem' => { :value => 'ipsum', :updated => Time.now.to_i },
+      'augue' => { :value => 'porta', :updated => Time.now.to_i },
+      'congue' => { :value => 'turpis', :updated => Time.now.to_i },
+      'vitae' => { :value => 'consequat', :updated => Time.now.to_i },
+      'accumsan' => { :value => 'nascetur', :updated => Time.now.to_i },
+      'diam' => { :value => 'dolor', :updated => Time.now.to_i },
+      'parturient' => { :value => 'viverra', :updated => Time.now.to_i },
+    }
+  end
+
+  def start
+    @slave_sockets = {}
+
+    semaphore = Mutex.new
+
+    run_server '0.0.0.0', PORT.to_s do |sock|
+      msg = sock.recv
+
+      reply = nil
+      semaphore.synchronize {
+        case msg['cmd']
+        when 'GET'
+          record = @data[msg['key']]
+          reply = {
+            'key' => msg['key'],
+            'value' => record[:value],
+            'updated' => record[:updated]
+          }
+        when 'PUT'
+          msg['updated'] ||= Time.now.to_i
+
+          @data[msg['key']] = { :value => msg['value'], :updated => msg['updated'] }
+
+          @active_links['slaves'].each do |slave_addr|
+            begin
+              slave_sock = DemoSocket.connect(slave_addr, PORT)
+              slave_sock.send msg
+              slave_sock.recv
+            rescue Errno::ECONNREFUSED, Errno::ECONNABORTED
+            end
+          end
+
+          @disabled_links['slaves'].each do |slave_addr|
+            @queues[slave_addr] << msg
+          end
+
+          record = @data[msg['key']]
+          reply = {
+            'key' => msg['key'],
+            'value' => record[:value],
+            'updated' => record[:updated]
+          }
+        when 'LIST'
+          reply = @data.map { |k,record|
+            { 'key' => k,
+              'value' => record[:value],
+              'updated' => record[:updated] }
+          }
+        end
+      }
+
+      sock.send(reply)
+      sock.close
+    end
+  end
+
+  def stop
+    shutdown_server '0.0.0.0', PORT.to_s
+    @slave_sockets.each do |addr, socket|
+      socket.close
+    end
+  end
+
+  alias :disable :stop
+  alias :enable :start
+end
+