HelloGoodbye

A daemon manager with a TCP interface built on top of EventMachine.

You can install the gem from RubyGems

gem install hello_goodbye

The foremen manager is the mother-ship for all your custom foremen that will spawn workers (or do whatever you wish).
A foreman itself, the manager creates a TCP console of its own so foremen can be reviewed and managed from the manager itself.

manager = HelloGoodbye::ForemenManager.new(:port => 8080, :server => "127.0.0.1")
# or...
manager = HelloGoodbye.manager(8080, "127.0.0.1")

To register foremen (before "start!"ing the manager), execute code like the following:

manager.register_foreman( :port => 8081, :class => HelloGoodbye::TestForeman )

If you want to capture errors (and you should -- if the manager goes down, everything is liable to go down with it), pass a block to the on_error method as follows:

manager.on_error do |e|
  # Do stuff. 
end

When you're all set up, fire away with the start! method:

manager.start!

This will block. After this is executed, all your manager and all your foremen should be listening in on their respective ports for your command.

After making a TCP connection to one of the consoles, communication should occur to and from the console using one of the following standard JSON packages.

Commands issued to a service should be formatted as follows:

{
  "command": "YOUR COMMAND"
}

Responses from the service will be formatted as follows:

{
  "success": true,
  "message": "MESSAGE FROM SERVICE",
  "results": []
}

Note the following:

• success can be true for false
• results will either be an array of data relavent to the command, or will be absent.

Once started, your manager will be available for TCP connections, and will respond to the following commands:

  XX will be "test" if the foreman name is TestForman.
  Otherwise, if XX is an integer, the ID of the active foreman will be consulted
  instead of the name.
</td>

  XX will be "test" if the foreman name is TestForman.
  Otherwise, if XX is an integer, the ID of the active foreman will be consulted
  instead of the name.
</td>

Foremen that you build must inherit from HelloGoodbye::Foreman. Beyond that, you should only have to implement a few instance methods that will be executed when the corresponding console commands are executed during a TCP connection:

def start
  # Start listening for events to respond to.
end

def stop
  # Stop listening for events.
end

Once started, your foreman will be available for TCP connections, and will respond to the following commands:

Although there is a generic

HelloGoodbye::ForemanConsole

that will hopefully suit the needs for most usecases, custom consoles can easily be created and attached to custom foremen as needed.

First, to implement your custom console, inherit from

HelloGoodbye::ForemanConsole

and override

receive_command

.

To make your own class extensible, and to make use of the built in console commands implemented in the

HelloGoodbye::ForemanConsole

class, you'll want to start with the template below when overriding this method:

def receive_command(command) # Process additional commands here. # Return if processes successfully super # Process the default commands. If no match, a failure response will be returned. end

The last little catch is this: you must let your custom forman class know which console to use. To do this, in your Foreman class, assuming your console class is HelloGoodbye::TestConsole (yes, your console must be in the HelloGoodbye module ):

set_console_type :test   # i.e. ":test" for TestConsole

Thus, the rules are as follow:

• Your console's class name must be prefixed with "Console".
• When setting this type with the class method, you must pass in a symbol matching the de-classified class name, minus the "Console" prefix.