hello_goodbye 0.1.0

data/lib/hello_goodbye/foremen_manager.rb

@@ -0,0 +1,103 @@
+module HelloGoodbye
+  require File.expand_path('../../hello_goodbye/console',__FILE__)
+  require File.expand_path('../../hello_goodbye/foreman',__FILE__)
+  class ForemenManager < Foreman
+
+    DEFAULT_MANAGER_PORT = 8080
+
+    set_console_type :manager
+
+    def self.default_manager_port
+      DEFAULT_MANAGER_PORT
+    end
+
+    def initialize(options={})
+      @next_foreman_id = -1
+      options.map do |key,value|
+        self.send("#{key}=",value) if self.respond_to?("#{key}=".to_sym)
+      end
+    end
+
+    def port
+      @port || DEFAULT_MANAGER_PORT
+    end
+
+    def foremen
+      @foremen ||= []
+    end
+
+    def next_foreman_id
+      @next_foreman_id += 1
+    end
+
+    # Registers a new forman
+    # Parameters:
+    # * foreman_hash
+    #     :port => (int) Port number to listen on.
+    #     :class => A reference to the foreman class
+    #               that will handle the connection and spawn
+    #               workers.
+    def register_foreman(foreman_hash)
+      self.foremen << foreman_hash.merge(:reference => nil, :id => next_foreman_id)
+    end
+
+    # Starts the manager console and all the
+    # registered foremen.
+    def start!
+      super do
+        self.start_foremen
+      end
+    end
+    
+    def on_error(&block)
+      EM::error_handler do |e|
+        block.call
+      end
+    end
+
+    # Start the consoles for all foremen.  This does not start
+    # employing workers.
+    def start_foremen
+      self.foremen.each do |foreman|
+        foreman[:reference] = foreman[:class].new(:server => self.server, 
+                                                  :port => foreman[:port])
+        foreman[:reference].start!
+      end
+    end
+
+    # Trigger all formen to either start or stop employing workers.
+    # Parameters:
+    # * mode => :start or :stop
+    # * id =>  The foreman's integer ID or name
+    def trigger_foreman(mode,id)
+      [].tap do |toggled_foremen|
+        self.foremen.each do |foreman|
+          if foreman[:reference].nil? || (id != "all" && foreman[:reference].my_name != id && foreman[:id] != id.to_i)
+            next
+          end
+          next if mode == :start && foreman[:reference].running?
+          next if mode == :stop && !foreman[:reference].running?
+
+          if mode == :start
+            foreman[:reference].employ
+          else
+            foreman[:reference].unemploy
+          end
+          toggled_foremen << foreman[:id]
+        end
+      end
+    end
+
+    def report
+      [].tap do |r|
+        self.foremen.each do |foreman|
+          r << {
+            :id =>  foreman[:id],
+            :name => foreman[:reference].my_name,
+            :status => foreman[:reference].status.to_s
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hello_goodbye/json/request.rb

@@ -0,0 +1,20 @@
+module HelloGoodbye
+  class Request
+    attr_accessor :request_hash
+    attr_reader :command
+
+    def initialize(str)
+      self.request_data=str
+    end
+
+    def request_data=(str)
+      @request_data = JSON.parse(str)
+      unless @request_data.include?("command")
+        raise ArgumentError, 
+          "The JSON string you supplied is invalid.  All requests must include a 'command' attribute."
+      end
+      @command = @request_data["command"]
+      @request_data
+    end
+  end
+end

data/lib/hello_goodbye/json/response.rb

@@ -0,0 +1,36 @@
+module HelloGoodbye
+  class Response
+    attr_accessor :success, :results, :message
+
+    def initialize(options={})
+      options.map do |key,value|
+        self.send("#{key}=".to_sym,value) if self.respond_to?("#{key}=".to_sym)
+      end
+    end
+
+    def success
+      (@success == true ? true : false )
+    end
+
+    def results=(r)
+      if r.nil?
+        @results = nil
+      else
+        @results = Array(r)
+      end
+    end 
+
+    def to_hash
+      h = {
+        "success" => self.success,
+        "message" => self.message.to_s
+      }
+      h["results"] = self.results if !self.results.nil?
+      h
+    end
+
+    def to_json
+      self.to_hash.to_json
+    end
+  end
+end

data/lib/hello_goodbye/version.rb

@@ -0,0 +1,3 @@
+module HelloGoodbye
+    VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").chomp
+end

data/lib/hello_goodbye.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'eventmachine'
+require 'json'
+
+require File.expand_path('../hello_goodbye/foremen_manager',__FILE__)
+
+module HelloGoodbye
+
+  # Resets the current foremen manager, so that the next time
+  # self.manager is called, a new ForemenManager instance will be
+  # created.
+  def self.reset!
+    @manager = nil
+  end
+
+  # Create a new manager or use the existing manager.  If an existing manager exists,
+  # port and server will be ignored.
+  # Parameters:
+  # * port:   The port the manager should connect to.
+  # * server: The server the service will run from.
+  def self.manager(port=ForemenManager.default_manager_port,server=Foreman.default_server)
+    @manager ||= ForemenManager.new(:port => port, :server => server)
+  end
+
+end

data/spec/hello_goodbye/console_spec.rb

@@ -0,0 +1,67 @@
+describe HelloGoodbye::Console do
+
+  let(:console) do
+    h = HelloGoodbye::Console.new 1
+
+    # Override EM method for this object
+    def h.send_data(data)
+      # Do nothing
+    end
+
+    def h.close_connection
+      # Do nothing
+    end
+
+    h
+  end
+
+  let(:test_console) do
+    HelloGoodbye::TestConsole.new 1
+  end
+
+  describe ".get" do
+    it "should raise error when console not recognized" do
+      expect{
+        HelloGoodbye::Console.get(:nothing)
+      }.to raise_error
+    end
+    it "should return a manager console" do
+      HelloGoodbye::Console.get(:manager).should be(HelloGoodbye::ManagerConsole)
+    end
+  end
+
+  describe "#receive_command" do
+    it "should return false on unknown actions" do
+      console.receive_command("custom_action").should be(false)
+    end
+    
+    it "should return true on known actions" do
+      console.receive_command("hello").should be(true)
+    end
+  end
+
+  context "basic commands" do
+    it "should reply to hello" do
+      command_to_console(console,"hello")["message"].should eq("hello")
+    end
+    it "should reply to goodbye and close connection" do
+      command_to_console(console,"goodbye")["message"].should eq("goodbye")
+      console.connection_closed?().should be_true
+    end
+    it "should report unknown commands" do
+      c = command_to_console(console,"unknown_action")
+      c["message"].should eq("unknown command")
+      c["success"].should be_false
+    end
+  end
+
+  context "custom consoles" do
+    it "should reply to default commands" do
+      command_to_console(test_console,"hello")["message"].should eq("hello")
+    end
+    it "should reply to custom commands" do
+      command_to_console(test_console,"custom")["message"].should eq("test command")
+    end
+  end
+
+end

data/spec/hello_goodbye/consoles/foreman_console_spec.rb

@@ -0,0 +1,35 @@
+describe HelloGoodbye::Console do
+
+  before(:all) do
+    @foreman = HelloGoodbye::TestForeman.new
+  end
+
+  let(:foreman_console) do
+    f = HelloGoodbye::TestConsole.new(1)
+    f.foreman = @foreman
+    f
+  end
+
+  let(:foreman) do
+    @foreman
+  end
+
+  context "starting and stopping the foreman" do
+    it "should start the foreman class from the console" do
+      r = command_to_console(foreman_console,"start")
+      r["message"].should eq("ok")
+      foreman.status.should be(:running)
+    end
+
+    it "should stop the foreman class from the console" do
+      r = command_to_console(foreman_console,"stop")
+      r["message"].should eq("ok")
+      foreman.status.should be(:stopped)
+    end
+
+    it "should stop report the status of the forman" do
+      r = command_to_console(foreman_console,"status")
+      r["message"].should eq("stopped")
+    end
+  end
+end

data/spec/hello_goodbye/consoles/manager_console_spec.rb

@@ -0,0 +1,47 @@
+describe HelloGoodbye::ManagerConsole do
+  before(:all) do
+    @manager = HelloGoodbye::ForemenManager.new
+    @manager.register_foreman({
+        :port => 8081,
+        :class => HelloGoodbye::TestForeman
+    })
+  end
+
+  let(:manager) do
+    @manager
+  end
+
+  let(:manager_console) do
+    m = HelloGoodbye::ManagerConsole.new(1)
+    m.foreman = @manager
+    m
+  end
+
+  context "when running with a manager" do
+    it "should report on active foreman" do
+      start_foremen_manager_and(manager) do |manager|
+        h = command_to_console(manager_console, "foremen")
+        h["results"].size.should be(1)
+      end
+    end
+
+    it "should start foremen by name" do
+      start_foremen_manager_and(manager) do |manager|
+        h = command_to_console(manager_console, "start test")
+        h["results"].first.should be(0)
+        manager_console.foreman.foremen.first[:reference].running?().should be_true
+
+        h = command_to_console(manager_console, "stop 0")
+        h["results"].first.should be(0)
+        manager_console.foreman.foremen.first[:reference].running?().should be_false
+      end
+    end
+
+    it "should start all foremen with 'all'" do
+      h = command_to_console(manager_console, "start all")
+      h["results"].first.should be(0)
+      manager_console.foreman.foremen.first[:reference].running?().should be_true
+    end
+  end
+
+end

data/spec/hello_goodbye/foremen_manager_spec.rb

@@ -0,0 +1,84 @@
+describe HelloGoodbye::ForemenManager do
+
+  before(:all) do
+    @manager = HelloGoodbye::ForemenManager.new
+  end
+
+  let(:manager) do
+    @manager
+  end
+
+  describe ".console_type" do
+    it "should be :manager" do
+      HelloGoodbye::ForemenManager.console_type.should be(:manager)
+    end
+  end
+
+  context "when registering foremen" do
+    it "should allow foremen to be registered" do
+      manager.register_foreman({
+        :port => 8081,
+        :class => HelloGoodbye::TestForeman
+      })
+      manager.register_foreman({
+        :port => 8082,
+        :class => HelloGoodbye::TestForeman
+      })
+      manager.foremen.size.should be(2)
+    end
+
+    it "should give each forman unique ids" do
+      manager.foremen.first[:id].should_not eq(manager.foremen[1][:id])
+    end
+    it "should not have references to objects" do
+      manager.foremen.each do |f|
+        f[:reference].should be_nil
+      end
+    end
+  end
+
+  context "when starting the manager" do
+    it "should spawn a responsive console" do
+      start_foremen_manager_and do |manager|
+        EM.run_block do 
+          expect { 
+            c = TCPSocket.open(default_server,default_port) 
+            c.close
+          }.to_not raise_error
+        end
+      end
+    end
+
+    it "should start foremen" do
+      start_foremen_manager_and(manager) do |manager|
+        manager.foremen.each do |f|
+          f[:reference].should be_a(HelloGoodbye::TestForeman)
+        end
+      end
+    end
+
+    it "should spawn a responsive console for foremen" do
+      start_foremen_manager_and(manager) do |manager|
+        EM.run_block do 
+          expect { 
+            c = TCPSocket.open(default_server,manager.foremen.first[:reference].port) 
+            c.close
+          }.to_not raise_error
+        end
+      end
+    end
+
+    it "should report active foreman" do
+      start_foremen_manager_and(manager) do |manager|
+        EM.run_block do 
+          manager.report.first.should eq({:id => manager.foremen.first[:id], 
+                                          :name => "test", :status => "stopped"})
+          manager.foremen.first[:reference].employ
+          manager.report.first.should eq({:id => manager.foremen.first[:id],
+                                         :name => "test", :status => "running"})
+        end
+      end
+
+    end
+  end
+end

data/spec/hello_goodbye/foremen_spec.rb

@@ -0,0 +1,64 @@
+describe HelloGoodbye::Foreman do
+  before(:all) do
+    @manager = HelloGoodbye::ForemenManager.new
+    @manager.register_foreman({
+        :port => 8081,
+        :class => HelloGoodbye::TestForeman
+    })
+  end
+  let(:manager) do
+    @manager
+  end
+
+  let(:foreman) do
+    HelloGoodbye::Foreman
+  end
+
+  let(:test_foreman) do
+    HelloGoodbye::TestForeman
+  end
+
+  describe ".console_type" do
+    it "should default to type :foreman" do
+      foreman.console_type.should be(:foreman)
+    end
+
+    it "should be overridable by custom consoles :test_foreman" do
+      test_foreman.console_type.should be(:test)
+    end
+  end
+
+  describe "starting the foreman" do
+    it "should only be startable once" do
+      f = foreman.new
+      EM.run_block do 
+        f.start!
+        expect {
+          f.start!
+        }.to raise_error
+      end
+    end
+  end
+
+  context "under the control of a manager" do
+    it "should be stopped initially" do
+      start_foremen_manager_and(manager) do |manager|
+        manager.foremen.first[:reference].status.should be(:stopped)
+      end
+    end
+    it "should be employable" do
+      start_foremen_manager_and(manager) do |manager|
+        f = manager.foremen.first[:reference]
+        f.employ
+        f.status.should be(:running)
+      end
+    end
+    it "should be unemployable" do
+      start_foremen_manager_and(manager) do |manager|
+        f = manager.foremen.first[:reference]
+        f.unemploy
+        f.status.should be(:stopped)
+      end
+    end
+  end
+end

data/spec/hello_goodbye/json/request_spec.rb

@@ -0,0 +1,28 @@
+describe HelloGoodbye::Request do
+  let(:request) do
+    HelloGoodbye::Request
+  end
+  describe "#request_data" do
+    it "should require valid json" do
+      expect {
+        request.new("So not JSON")
+      }.to raise_error
+    end
+    
+    it "should require a command attribute" do
+      expect {
+        request.new '{"success": true}'
+      }.to raise_error
+    end
+
+    it "should be successful with a command" do
+      expect {
+        request.new '{"command": "hello"}'
+      }.to_not raise_error
+    end
+
+    it "should set command attribute" do
+      request.new('{"command": "hello"}').command.should eq("hello")
+    end
+  end
+end

data/spec/hello_goodbye/json/response_spec.rb

@@ -0,0 +1,35 @@
+describe HelloGoodbye::Response do
+  let(:results_response) do
+    HelloGoodbye::Response.new :success => true,
+      :message => "Hi Mom!", :results => [{"color" => "blue"}]
+  end
+  let(:response) do
+    HelloGoodbye::Response.new
+  end
+
+  it "should set fields from initialization" do
+    results_response.success.should be_true
+    results_response.message.should eq("Hi Mom!")
+    results_response.results.first.should eq({"color" => "blue"})
+  end
+
+  it "should default to unsuccessful" do
+    response.success.should be_false
+  end
+
+  it "should exclude results from hash when there are none" do
+    response.to_hash["results"].should be_nil
+  end
+
+  it "should build a hash based on values" do
+    results_response.to_hash["message"].should eq("Hi Mom!")
+  end
+
+  it "should build a hash based on values" do
+    results_response.to_hash["results"].size.should eq(1)
+  end
+
+  it "should return a json string" do
+    response.to_json.should be_a(String)
+  end
+end

data/spec/hello_goodbye_spec.rb

@@ -0,0 +1,21 @@
+describe HelloGoodbye do
+  describe "Mother Module" do
+    it  "should create a new manager" do
+      m = HelloGoodbye.manager
+      m.should be_a(HelloGoodbye::ForemenManager)
+    end
+
+    it "should return the same manager instance" do
+      m = HelloGoodbye.manager(2000,"joshcom.net")
+      m2 = HelloGoodbye.manager
+      m.should be(m2)
+    end
+
+    it "should create a new manager instance after reset!" do
+      m = HelloGoodbye.manager(2000,"joshcom.net")
+      HelloGoodbye.reset!
+      m2 = HelloGoodbye.manager
+      m.should_not be(m2)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--require spec_helper

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../../lib/hello_goodbye',__FILE__)
+require File.expand_path('../../spec/test_foreman',__FILE__)
+require File.expand_path('../../spec/test_console',__FILE__)
+require File.expand_path('../../lib/hello_goodbye/json/request',__FILE__)
+require File.expand_path('../../lib/hello_goodbye/json/response',__FILE__)
+
+require 'rspec'
+
+# Possibly the most important helper method.
+# This method, in the following order:
+# 1. Starts an event loop
+# 2. Executes #start! on either the parameter ForemenManager or
+#    creates a new ForemenManager and executes start! on that.
+# 3. Yields to a given block, passing the ForemenManager to that block.
+# 4. Stops the event loop.
+def start_foremen_manager_and(f=spec_manager)
+  f.instance_variable_set("@foreman_started",false)
+  EM.run_block do
+    f.start!
+    yield(f)
+  end
+end
+
+def command_to_json_str(command)
+  {
+    :command => command
+  }.to_json
+end
+
+def command_to_console(console,command)
+  sent_data = nil
+  override_method(console,'send_data') do |data|
+    sent_data = data
+  end
+  override_method(console,'close_connection') do
+    @test_connection_closed = true
+  end
+  override_method(console,'connection_closed?') do
+    @test_connection_closed || false
+  end
+  console.receive_command(command)
+  build_response_hash(sent_data)
+end
+
+def override_method(console,method,&block)
+  (class << console; self; end).send(:define_method, method) do |*args|
+      block.call(*args)
+  end
+end
+
+def build_response_hash(data)
+  JSON.parse(data)
+end
+
+def default_server
+  "127.0.0.1"
+end
+
+def default_port
+  8080
+end
+
+def spec_manager
+  HelloGoodbye::ForemenManager.new(:port => default_port,
+                                   :server => default_server)
+end

data/spec/test_console.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../lib/hello_goodbye',__FILE__)
+
+module HelloGoodbye
+  class TestConsole < ForemanConsole
+    def receive_command(command)
+      case command
+      when "custom"
+        send_response :success => true,
+          :message => "test command"
+        return true
+      when "error"
+        send_response :success => true,
+          :message => "oops"
+        raise RuntimeError, "Oh noooooes!"
+      when "kill"
+        send_response :success => true,
+          :message => "Why me?"
+        EM.stop
+      end
+      super
+    end
+  end
+end

data/spec/test_foreman.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../lib/hello_goodbye',__FILE__)
+
+module HelloGoodbye
+  class TestForeman < Foreman
+    set_console_type :test
+    
+    def start
+      # Do nothing
+    end
+
+    def stop
+      # Do nothing
+    end
+  end
+end