erlnixify 0.0.1

data/features/node.feature

@@ -0,0 +1,35 @@
+Feature: Node
+  In order to manage a running erlang node
+  As a developer
+  I want to be able to bring it up and shut it down
+  and regularly check to see if its still running as expected
+
+  Scenario: Basic startup
+    Given a valid configuration
+    And the erlang node is started
+    When the node is brought up
+    Then no errors or problems occur
+
+  Scenario: Startup failure
+    Given a valid configuration with invalid command
+    And the erlang node is started
+    When the node fails
+    Then an exception occures
+
+  Scenario: Check failure
+    Given a valid configuration with invalid check command
+    And the erlang node is started
+    When the check fails
+    And the erlang node is halted
+
+  Scenario: Check Timeout
+    Given a valid configuration with a long running check comamnd
+    And the erlang node is started
+    When the check command times out
+    Then the erlang node is halted
+
+  Scenario: Signal TERM
+    Given a valid configuration
+    And the erlang node is started
+    When a term signal is recieved
+    Then the erlang node is halted

data/features/settings.feature

@@ -0,0 +1,20 @@
+Feature: Settings
+  In order to provide a 'templatable' settings file
+  As a developer
+  I want to be able to provide a settings file
+  and have the system warn me when I get settings wrong
+
+  Scenario: A basic yaml settings file
+    Given a settings file
+    When I load that settings file
+    Then the settings should be available in the settings object
+
+  Scenario: Command line options override config
+    Given an options object that contains config values
+    When a new settings file is loaded up using that options
+    Then the command line options override the file options
+
+  Scenario: Reasonable Default Settings
+    Given a lack of a config file and command line options
+    When a settings are loaded
+    Then that settings object contains sane defaults

data/features/step_definitions/node_steps.rb

@@ -0,0 +1,108 @@
+
+
+Given(/^a valid configuration$/) do
+  hostname = `hostname -f`.strip
+  @opts = Erlnixify::Opts.new(["--cookie", "fubachu",
+                               "--startuptimeout", "10",
+                               "--checkinterval", "10",
+                               "--name", "foo",
+                               "--command", "erl -noshell -setcookie fubachu -name foo@#{hostname}"
+                              ])
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+Then(/^no errors or problems occur$/) do
+  assert @node.is_running?
+  @node.halt_nicely
+  sleep @settings[:startuptimeout]
+  assert (not @node.is_running?)
+end
+
+Given(/^the erlang node is started$/) do
+  @node = Erlnixify::Node.new @settings
+  Thread.new do
+    begin
+      @node.start
+    rescue Erlnixify::NodeError => node_error
+      @node_start_error = node_error
+    rescue Exception => e
+      assert_fail "Other exception should not occur #{e.message}"
+    end
+  end
+  sleep (@settings[:startuptimeout] + 30)
+end
+
+When(/^the node is brought up$/) do
+  assert @node.is_running?
+end
+
+Given(/^a valid configuration with invalid command$/) do
+  hostname = `hostname -f`.strip
+  @opts = Erlnixify::Opts.new(["--cookie", "fubachu",
+                               "--startuptimeout", "10",
+                               "--checkinterval", "10",
+                               "--name", "foo",
+                               "--command", "this should fail"
+                              ])
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+When(/^the node fails$/) do
+  assert @node_start_error != nil, "An NodeError was expected to be thrown"
+  assert @node.is_running? == false, "Node is still running"
+end
+
+Then(/^an exception occures$/) do
+  assert @node_start_error != nil, "An NodeError was expected to be thrown"
+end
+
+Given(/^a valid configuration with invalid check command$/) do
+  hostname = `hostname -f`.strip
+  @opts = Erlnixify::Opts.new(["--cookie", "fubachu",
+                               "--startuptimeout", "10",
+                               "--checkinterval", "10",
+                               "--name", "foo",
+                               "--command", "erl -noshell -setcookie fubachu -name foo@#{hostname}",
+                               "--check", "invalid check",
+
+                              ])
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+When(/^the check fails$/) do
+  assert @node_start_error.message == "Node check failed"
+end
+
+
+When(/^the erlang node is halted$/) do
+  assert false == @node.is_running?, "The node is running when it should not be"
+end
+
+Given(/^a valid configuration with a long running check comamnd$/) do
+  check_time = 60 * 1000 # 60 seconds in milliseconds
+  hostname = `hostname -f`.strip
+  @opts = Erlnixify::Opts.new(["--cookie", "fubachu",
+                               "--startuptimeout", "10",
+                               "--checkinterval", "10",
+                               "--name", "foo",
+                               "--command", "erl -noshell -setcookie fubachu -name foo@#{hostname}",
+                               "--check", "timer sleep [#{check_time}]",
+
+                              ])
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+When(/^the check command times out$/) do
+  sleep 60 # should be a enough given the timeout
+
+  assert @node_start_error.message == "Check command timeout occurred", "Timeout did not occur"
+end
+
+When(/^a term signal is recieved$/) do
+  begin
+    Process.kill("TERM", $$)
+    assert_fail "Did not recieve error"
+  rescue Erlnixify::NodeError => e
+    assert e.message == "SIGTERM recieved, shutting down"
+  end
+end

data/features/step_definitions/settings_steps.rb

@@ -0,0 +1,63 @@
+require "erlnixify"
+
+Before do
+end
+
+After do
+end
+
+Given(/^a settings file$/) do
+  file = File.dirname(__FILE__) + '/../test_data/settings_config.yml'
+  @opts = Erlnixify::Opts.new(["--config", file])
+end
+
+When(/^I load that settings file$/) do
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+Then(/^the settings should be available in the settings object$/) do
+  assert_equal 60, @settings[:startuptimeout]
+  assert_equal "/some/place", @settings[:release]
+  assert_equal "/some/root/file", @settings[:erlang]
+  assert_equal "mynode", @settings[:name]
+  assert_equal "sleep 10", @settings[:command]
+  assert_equal "testcookie!", @settings[:cookie]
+  assert_equal 30, @settings[:checkinterval]
+end
+
+Given(/^an options object that contains config values$/) do
+  file = File.dirname(__FILE__) + '/../test_data/settings_config.yml'
+  @opts = Erlnixify::Opts.new(["--config", file,
+                               "--checkinterval", "100",
+                               "--startuptimeout", "500",
+                               "--cookie", "fubachu"])
+end
+
+When(/^a new settings file is loaded up using that options$/) do
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+Then(/^the command line options override the file options$/) do
+  assert_equal 500, @settings[:startuptimeout]
+  assert_equal "/some/place", @settings[:release]
+  assert_equal "/some/root/file", @settings[:erlang]
+  assert_equal "mynode", @settings[:name]
+  assert_equal "sleep 10", @settings[:command]
+  assert_equal "fubachu", @settings[:cookie]
+  assert_equal 100, @settings[:checkinterval]
+end
+
+
+Given(/^a lack of a config file and command line options$/) do
+  @opts = Erlnixify::Opts.new([])
+end
+
+When(/^a settings are loaded$/) do
+  @settings = Erlnixify::Settings.new(@opts)
+end
+
+Then(/^that settings object contains sane defaults$/) do
+  assert_equal 60, @settings[:startuptimeout]
+  assert_equal ENV["HOME"], @settings[:home]
+  assert_equal 30, @settings[:checkinterval]
+end

data/features/test_data/settings_config.yml

@@ -0,0 +1,7 @@
+release: /some/place
+erlang: /some/root/file
+name: mynode
+command: sleep 10
+cookie: testcookie!
+startuptimeout: 60
+checkinterval: 30

data/lib/erlnixify/exceptions.rb

@@ -0,0 +1,6 @@
+module Erlnixify
+  # An Error thrown from the erlnixify system eventually this should
+  # by expanded to individual error types.
+  class NodeError < StandardError
+  end
+end

data/lib/erlnixify/node.rb

@@ -0,0 +1,135 @@
+require 'logger'
+require 'erlnixify/exceptions'
+
+module Erlnixify
+  COMMAND_WRAPPER = "%{erl_interface}/bin/erl_call -n %{fullnode} \
+-c '%{cookie}' -a '%{cmd}'"
+
+  SHUTDOWN_COMMAND = "init stop"
+
+  BRUTAL_SHUTDOWN_COMMAND = "erlang halt 127"
+
+  # The process class owns the Running erlang process. It knows how to
+  # query it if its active, and kill it if something goes long. This
+  # class is the guts of erlnixify
+  class Node
+    def initialize(settings)
+      @settings = settings
+      @command = @settings[:command] % settings.settings
+      @check_command = self.interpolate_cmd(@settings[:check])
+      @halt_command = self.interpolate_cmd(SHUTDOWN_COMMAND)
+      @brutal_halt_command = self.interpolate_cmd(BRUTAL_SHUTDOWN_COMMAND)
+      @checkregex = Regexp.new @settings[:checkregex]
+
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::DEBUG
+
+      Signal.trap("TERM") do
+        self.halt_nicely
+        raise NodeError, "SIGTERM recieved, shutting down"
+      end
+
+      Signal.trap("INT") do
+        self.halt_nicely
+        raise NodeError, "SIGINT recieved, shutting down"
+      end
+
+      at_exit { self.external_kill }
+    end
+
+    def start
+      @log.debug "starting process"
+      env = {}
+      env["HOME"] = @settings[:home] if @settings[:home]
+
+      begin
+        @log.debug "spawning command '#{@command}' with #{env}"
+        @pid = Process.spawn(env, @command)
+      rescue Errno::ENOENT
+        @log.debug "Invalid command provided, raising error"
+        raise NodeError, "Command does not exist"
+      end
+
+      @log.debug "waiting for #{@settings[:startuptimeout]} seconds for startup"
+      sleep @settings[:startuptimeout]
+      self.monitor
+    end
+
+    def monitor
+      @log.debug "starting monitor of Pid #{@pid}"
+      loop do
+        if is_running?
+          self.check
+          sleep @settings[:checkinterval]
+        else
+          raise NodeError, "Node not running"
+        end
+        break if @stop
+        @log.debug "Node responded correctly, continuing check"
+      end
+    end
+
+    def check
+      begin
+        Timeout.timeout(@settings[:checktimeout]) do
+          self.raw_check
+        end
+      rescue Timeout::Error
+        self.halt_nicely
+        raise NodeError, "Check command timeout occurred"
+      end
+    end
+
+    def raw_check
+      @log.debug "Checking the status of Pid #{@pid}"
+      @log.debug "#{@check_command} =~ #{@checkregex}"
+      result = `#{@check_command}`
+      @log.debug "got #{result}"
+      if not (result =~ @checkregex)
+        @log.debug "Check failed, halting system"
+        self.halt_nicely
+        raise NodeError, "Node check failed"
+      end
+    end
+
+    def is_running?
+      @log.debug "Checking if Pid (#{@pid}) is running"
+      if @pid
+        begin
+          Process.getpgid(@pid)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      else
+        false
+      end
+    end
+
+    def halt_nicely
+      `#{@halt_command}`
+      sleep @settings[:checkinterval]
+      if self.is_running?
+        self.halt_brutally
+      end
+    end
+
+    def halt_brutally
+      `#{@brutal_halt_command}`
+      sleep @settings[:checkinterval]
+      if self.is_running?
+        self.external_kill
+      end
+    end
+
+    def external_kill
+      Process.kill("KILL", @pid) if @pid
+    end
+
+    def interpolate_cmd(cmd)
+      local_settings = @settings.settings.clone
+      local_settings[:cmd] = cmd % local_settings
+      COMMAND_WRAPPER % local_settings
+    end
+  end
+end

data/lib/erlnixify/opts.rb

@@ -0,0 +1,45 @@
+require 'slop'
+
+module Erlnixify
+
+  # The Opts class provides options parsing support for erlnixify. It
+  # is similar to settings with the exception that it is designed to
+  # get its values from the command line.
+  #
+  class Opts
+
+    attr_reader :options
+
+    def initialize(args)
+      opts = Slop.parse(args) do
+
+        banner = "Usage: erlnixify [options]"
+
+        on :b, :release=, 'Release Root Directory'
+        on :e, :erlang=, 'Erlang Root Directory'
+        on :o, :home=, "The home directory to explicitly set"
+        on :n, :name=, "The short name of the node to be managed"
+        on :fullnode=, "The fully qualified node name"
+        on :m, :command=, "The command to run to start the release"
+        on :k, :check=, "The command to check if the release is active"
+        on :r, :checkregex=, "The regex that must match to the output of check command"
+        on :x, :cookiefile=, "A file that contains the erlang cookie, not needed if cookie is set"
+        on :i, :cookie=, "The cookie itself, not needed if cookie-file is set"
+        on(:t, :startuptimeout=,
+            "The amount of time to let the system startup in seconds",
+            as: Integer)
+        on(:a, :checkinterval=,
+            "How often erlnixify should check to see if the system is still running",
+            as: Integer)
+        on(:w, :checktimeout=,
+           "The longest time a check can run, defaults to 30 seconds",
+           as: Integer)
+        on :c, :config=, "A file that contains the YAML based config for this system"
+        on :v, :version, "Show the Version"
+      end
+
+      @options = opts.to_hash
+    end
+  end
+
+end

data/lib/erlnixify/settings.rb

@@ -0,0 +1,127 @@
+require 'yaml'
+
+module Erlnixify
+
+  # Provides a library for settings to be accessed from accross the
+  # system
+  class Settings
+    attr_accessor :settings
+    attr_accessor :options
+
+    STARTUP_TIMEOUT = 60
+    CHECK_INTERVAL = 30
+    CHECK_TIMEOUT = 30
+    CHECK_COMMAND = "erlang statistics [reductions]"
+    CHECK_REGEX = "^{\\d+, \\d+}$"
+
+    def initialize(opts)
+      @options = opts
+      config = @options.options[:config]
+
+      @settings = self.default_settings
+
+      self.load! config if config
+      self.merge(@options.options)
+      self.post_settings_setup
+    end
+
+    def default_settings
+      defaults = {release: nil,
+        erlang: nil,
+        home: ENV["HOME"],
+        name: nil,
+        fullnode: nil,
+        command: nil,
+        check: CHECK_COMMAND,
+        checkregex: CHECK_REGEX,
+        cookiefile: nil,
+        cookie: nil,
+        startuptimeout: STARTUP_TIMEOUT,
+        checkinterval: CHECK_INTERVAL,
+        checktimeout: CHECK_TIMEOUT,
+        config: nil}
+      defaults
+    end
+
+    def load!(filename, options = {})
+      newsets = YAML::load_file(filename)
+
+      env = options[:env].to_sym if options[:env]
+
+      if env
+        newsets = newsets[env] if newsets[env]
+      end
+
+      self.merge(newsets)
+    end
+
+    def [](key)
+      return @settings[key]
+    end
+
+    def merge(data)
+      @settings = @settings.inject({}) do |newhash, (key, value)|
+        symkey = key.to_sym
+        data_value = data[symkey]
+        data_value = data[key.to_s] unless data_value
+        if data_value
+          newhash[symkey] = data_value
+        else
+          newhash[symkey] = value
+        end
+        newhash
+      end
+    end
+
+    def post_settings_setup
+      @settings[:erlang] = self.find_erlang_root
+      @settings[:cookie] = self.find_cookie
+      @settings[:erl_interface] = self.find_erl_interface
+      @settings[:fullnode] = self.find_full_node
+    end
+
+    def find_erlang_root
+      if @settings[:erlang]
+        @settings[:erlang]
+      elsif File.directory? "/usr/local/lib/erlang"
+        "/usr/local/lib/erlang"
+      elsif File.directory? "/usr/lib/erlang"
+        "/usr/lib/erlang"
+      end
+    end
+
+
+    def find_cookie
+      cookie_file = @settings[:cookiefile]
+      if @settings[:cookie]
+        @settings[:cookie]
+      elsif cookie_file
+        if File.exists? cookie_file
+          IO.read cookie_file
+        else
+          raise RuntimeError, "Cookie file does not exist"
+        end
+      end
+    end
+
+    def find_full_node
+      if @settings[:fullnode]
+        @settings[:fullnode]
+      else
+        hostname = `hostname -f`.strip
+        node = @settings[:name]
+        "#{node}@#{hostname}"
+      end
+    end
+
+    def find_erl_interface
+      erlang_root = @settings[:erlang]
+      release_root = @settings[:release]
+      if erlang_root && (File.directory? erlang_root)
+        Dir.glob("#{erlang_root}/lib/erl_interface-*").first
+      elsif release_root && (File.directory? release_root)
+        Dir.glob("#{release_root}/lib/erl_interface-*").first
+      end
+    end
+  end
+end

data/lib/erlnixify/version.rb

@@ -0,0 +1,3 @@
+module Erlnixify
+  VERSION = "0.0.1"
+end

data/lib/erlnixify.rb

@@ -0,0 +1,24 @@
+require "erlnixify/version"
+require "erlnixify/opts"
+require "erlnixify/settings"
+require "erlnixify/node"
+
+module Erlnixify
+
+  def main(args)
+    @opts = Opts.new(args)
+
+    if opts.version?
+      puts Erlnixify::VERSION
+      exit 0
+    end
+
+    @settings = Settings.new(opts)
+    @process = Process.new(@settings)
+    begin
+      @process.start
+    rescue Erlnixify::NodeError
+      exit 127
+    end
+  end
+end

data/reek.yml

@@ -0,0 +1,8 @@
+Duplication:
+  max_calls: 2
+
+LongMethod:
+  max_statements: 10
+  exclude:
+  - initialize
+  enabled: true

data/settings.feature

@@ -0,0 +1,20 @@
+Feature: Settings
+  In order to provide a 'templatable' settings file
+  As a developer
+  I want to be able to provide a settings file
+  and have the system warn me when I get settings wrong
+
+  Scenario: A basic yaml settings file
+    Given a settings file
+    When I load that settings file
+    Then the settings should be available in the settings object
+
+  Scenario: Command line options override config
+    Given an options object that contains config values
+    When a new settings file is loaded up using that options
+    Then the command line options override the file options
+
+  Scenario: Reasonable Default Settings
+    Given a lack of a config file and command line options
+    When a settings are loaded
+    Then that settings object contains sane defaults