ringleader 0.0.2 → 1.0.0

data/lib/ringleader/config.rb

@@ -3,27 +3,51 @@ module Ringleader
 
     DEFAULT_IDLE_TIMEOUT = 1800
     DEFAULT_STARTUP_TIMEOUT = 30
-    DEFAULT_HOSTNAME = "127.0.0.1"
-    REQUIRED_KEYS = %w(dir command server_port app_port idle_timeout)
+    DEFAULT_HOST= "127.0.0.1"
+    REQUIRED_KEYS = %w(dir command app_port server_port)
 
-    def initialize(file)
-      @config = YAML.load(File.read(file))
+    TERMINAL_COLORS = [:red, :green, :yellow, :blue, :magenta, :cyan]
+
+    attr_reader :apps
+
+    # Public: Load the configs from a file
+    #
+    # file   - the yml file to load the config from
+    # boring - use terminal colors instead of a rainbow for app colors
+    def initialize(file, boring=false)
+      config_data = YAML.load(File.read(file))
+      configs = convert_and_validate config_data, boring
+      @apps = Hash[*configs.flatten]
     end
 
-    def apps
-      unless @app
-        configs = @config.map do |name, options|
-          options["name"] = name
-          options["hostname"] ||= DEFAULT_HOSTNAME
-          options["idle_timeout"] ||= DEFAULT_IDLE_TIMEOUT
-          options["startup_timeout"] ||= DEFAULT_STARTUP_TIMEOUT
-          validate name, options
-          [name, OpenStruct.new(options)]
+    # Private: convert a YML hash to an array of name/OpenStruct pairs
+    #
+    # Does validation for each app config and raises an error if anything is
+    # wrong. Sets default values for missing options, and assigns colors to each
+    # app config.
+    #
+    # configs - a hash of config data
+    # boring  - whether or not to use a rainbow of colors for the apps
+    #
+    # Returns [ [app_name, OpenStruct], ... ]
+    def convert_and_validate(configs, boring)
+      assign_colors configs, boring
+      configs.map do |name, options|
+        options["name"] = name
+        options["host"] ||= DEFAULT_HOST
+        options["idle_timeout"] ||= DEFAULT_IDLE_TIMEOUT
+        options["startup_timeout"] ||= DEFAULT_STARTUP_TIMEOUT
+
+        if command = options.delete("rvm")
+          options["command"] = "source ~/.rvm/scripts/rvm && rvm --with-rubies rvmrc exec -- #{command}"
         end
 
-        @apps = Hash[*configs.flatten]
+        validate name, options
+
+        options["dir"] = File.expand_path options["dir"]
+
+        [name, OpenStruct.new(options)]
       end
-      @apps
     end
 
     # Private: validate that the options have all of the required keys
@@ -34,5 +58,24 @@ module Ringleader
         end
       end
     end
+
+    # Private: assign a color to each application configuration.
+    #
+    # configs - the config data to modify
+    # boring  - use boring standard terminal colors instead of a rainbow.
+    def assign_colors(configs, boring)
+      sorted = configs.sort_by(&:first).map(&:last)
+      if boring
+        sorted.each.with_index do |config, i|
+          config["color"] = TERMINAL_COLORS[ i % TERMINAL_COLORS.length ]
+        end
+      else
+        offset = 360/configs.size
+        sorted.each.with_index do |config, i|
+          config["color"] = Color::HSL.new(offset * i, 100, 50).html
+        end
+      end
+    end
+
   end
 end

data/lib/ringleader/controller.rb

@@ -0,0 +1,30 @@
+module Ringleader
+  class Controller
+    include Celluloid
+    include Celluloid::Logger
+
+    def initialize(configs)
+      @apps = {}
+      configs.each do |name, config|
+        @apps[name] = App.new(config)
+      end
+    end
+
+    def apps
+      @apps.values.sort_by { |a| a.name }
+    end
+
+    def app(name)
+      @apps[name]
+    end
+
+    def stop
+      exit if @stopping # if ctrl-c called twice...
+      @stopping = true
+      info "shutting down..."
+      @apps.values.map do |app|
+        Thread.new { app.stop }
+      end.map(&:join)
+    end
+  end
+end

data/lib/ringleader/process.rb

@@ -0,0 +1,145 @@
+module Ringleader
+
+  # Represents an instance of a configured application.
+  class Process
+    include Celluloid
+    include Celluloid::Logger
+    include NameLogger
+
+    attr_reader :config
+
+    # Create a new App instance.
+    #
+    # config - a configuration object for this app
+    def initialize(config)
+      @config = config
+      @starting = @running = false
+    end
+
+    # Public: query if the app is running
+    def running?
+      @running
+    end
+
+    # Public: start the application.
+    #
+    # This method is intended to be used synchronously. If the app is already
+    # running, it'll return immediately. If the app hasn't been started, or is
+    # in the process of starting, this method blocks until it starts or fails to
+    # start correctly.
+    #
+    # Returns true if the app started, false if not.
+    def start
+      if @running
+        true
+      elsif @starting
+        wait :running
+      else
+        start_app
+      end
+    end
+
+    # Public: stop the application.
+    #
+    # Sends a SIGTERM to the app's process, and expects it to exit like a sane
+    # and well-behaved application within 30 seconds before sending a SIGKILL.
+    def stop
+      return unless @pid
+
+      info "stopping #{@pid}"
+      @master.close unless @master.closed?
+      debug "kill -TERM #{@pid}"
+      ::Process.kill "TERM", -@pid
+
+      kill = after 30 do
+        if @running
+          warn "process #{@pid} did not shut down cleanly, killing it"
+          debug "kill -KILL #{@pid}"
+          ::Process.kill "KILL", -@pid
+        end
+      end
+
+      wait :running # wait for the exit callback
+      kill.cancel
+
+    rescue Errno::ESRCH, Errno::EPERM
+      exited
+    end
+
+    # Internal: callback for when the application port has opened
+    def port_opened
+      info "listening on #{config.host}:#{config.app_port}"
+      signal :running, true
+    end
+
+    # Internal: callback for when the process has exited.
+    def exited
+      debug "pid #{@pid} has exited"
+      info "exited."
+      @running = false
+      @pid = nil
+      @wait_for_port.terminate if @wait_for_port.alive?
+      @wait_for_exit.terminate if @wait_for_exit.alive?
+      signal :running, false
+    end
+
+    # Private: start the application process and associated infrastructure
+    #
+    # Intended to be synchronous, as it blocks until the app has started (or
+    # failed to start).
+    #
+    # Returns true if the app started, false if not.
+    def start_app
+      @starting = true
+      info "starting process `#{config.command}`"
+
+      # give the child process a terminal so output isn't buffered
+      @master, slave = PTY.open
+      @pid = ::Process.spawn %Q(bash -c "#{config.command}"),
+        :in => slave,
+        :out => slave,
+        :err => slave,
+        :chdir => config.dir,
+        :pgroup => true
+      slave.close
+      proxy_output @master
+      debug "started with pid #{@pid}"
+
+      @wait_for_exit = WaitForExit.new @pid, Actor.current
+      @wait_for_port = WaitForPort.new config.host, config.app_port, Actor.current
+
+      timer = after config.startup_timeout do
+        warn "application startup took more than #{config.startup_timeout}"
+        stop!
+      end
+
+      @running = wait :running
+
+      @starting = false
+      timer.cancel
+
+      @running
+    rescue Errno::ENOENT
+      @starting = false
+      @running = false
+      false
+    ensure
+      unless @running
+        warn "could not start `#{config.command}`"
+      end
+    end
+
+    # Private: proxy output streams to the logger.
+    #
+    # Fire and forget, runs in its own thread.
+    def proxy_output(input)
+      Thread.new do
+        until input.eof?
+          info input.gets.strip
+        end
+      end
+    end
+
+  end
+
+end

data/lib/ringleader/server.rb

@@ -0,0 +1,116 @@
+module Ringleader
+  class Server < Reel::Server
+    include Celluloid::IO # hurk
+    include Celluloid::Logger
+
+    ASSET_PATH = Pathname.new(File.expand_path("../../../assets", __FILE__))
+    ACTIONS = %w(enable disable stop start restart).freeze
+
+    def initialize(controller, host, port)
+      debug "starting webserver on #{host}:#{port}"
+      super host, port, &method(:on_connection)
+      @controller = controller
+      info "web control panel started on http://#{host}:#{port}"
+    end
+
+    def on_connection(connection)
+      request = connection.request
+      route connection, request if request
+    end
+
+    # thanks to dcell explorer for this code
+    def route(connection, request)
+      if request.url == "/"
+        path = "index.html"
+      else
+        path = request.url[%r{^/([a-z0-9\.\-_]+(/[a-z0-9\.\-_]+)*)$}, 1]
+      end
+
+      if !path or path[".."]
+        connection.respond :not_found, "Not found"
+        debug "404 #{path}"
+        return
+      end
+
+      case request.method
+      when :get
+        if path == "apps"
+          app_index connection
+        elsif path =~ %r(^apps/\w+)
+          show_app path, request.body, connection
+        else
+          static_file path, connection
+        end
+      when :post
+        update_app path, request.body, connection
+      end
+    end
+
+    def app_index(connection)
+      json = @controller.apps.map { |app| app_as_json(app) }.to_json
+      connection.respond :ok, json
+      debug "GET /apps: 200"
+    end
+
+    def static_file(path, connection)
+      filename = ASSET_PATH + path
+      if filename.exist?
+        mime_type = content_type_for filename.extname
+        filename.open("r") do |file|
+          connection.respond :ok, {"Content-type" => mime_type}, file
+        end
+        debug "GET #{path}: 200"
+      else
+        connection.respond :not_found, "Not found"
+        debug "GET #{path}: 404"
+      end
+    end
+
+    def show_app(uri, body, connection)
+      _, name, _ = uri.split("/")
+      app = @controller.app name
+      if app
+        connection.respond :ok, app_as_json(app).to_json
+        debug "GET #{uri}: 200"
+      else
+        connection.respond :not_found, "Not found"
+        debug "GET #{uri}: 404"
+      end
+    end
+
+    def update_app(uri, body, connection)
+      _, name, action = uri.split("/")
+      app = @controller.app name
+      if app && ACTIONS.include?(action)
+        app.send action
+        connection.respond :ok, app_as_json(app).to_json
+        debug "POST #{uri}: 200"
+      else
+        connection.respond :not_found, "Not found"
+        debug "POST #{uri}: 404"
+      end
+    end
+
+    def app_as_json(app)
+      AppSerializer.new(app)
+    end
+
+    def content_type_for(extname)
+      case extname
+      when ".html"
+        "text/html"
+      when ".js"
+        "application/json"
+      when ".css"
+        "text/css"
+      when ".ico"
+        "image/x-icon"
+      when ".png"
+        "image/png"
+      else
+        "text/plain"
+      end
+    end
+
+  end
+end

data/lib/ringleader/version.rb

@@ -1,3 +1,3 @@
 module Ringleader
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/lib/ringleader/wait_for_exit.rb

@@ -8,7 +8,7 @@ module Ringleader
     end
 
     def wait
-      Process.waitpid @pid
+      ::Process.waitpid @pid
       @app.exited!
       terminate
     end

data/ringleader.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency "celluloid", "~> 0.11.0"
   gem.add_dependency "celluloid-io", "~> 0.11.0"
+  gem.add_dependency "reel", "~> 0.1.0"
   gem.add_dependency "trollop", "~> 1.16.2"
   gem.add_dependency "rainbow", "~> 1.1.4"
   gem.add_dependency "color", "~> 1.4.1"

data/spec/fixtures/config.yml

@@ -2,7 +2,7 @@
 main_site:
   dir: "~/apps/main"
   command: "bundle exec foreman start"
-  hostname: "0.0.0.0"
+  host: "0.0.0.0"
   server_port: 3000
   app_port: 4000
   idle_timeout: 1800

data/spec/fixtures/no_app_port.yml

@@ -0,0 +1,5 @@
+---
+main_site:
+  dir: "~/apps/main"
+  command: "bundle exec foreman start"
+  server_port: 3000

data/spec/fixtures/no_server_port.yml

@@ -0,0 +1,6 @@
+
+---
+main_site:
+  dir: "~/apps/main"
+  command: "bundle exec foreman start"
+  app_port: 4000

data/spec/fixtures/rvm.yml

@@ -0,0 +1,6 @@
+---
+rvm_app:
+  dir: "~/apps/main"
+  rvm: "foreman start"
+  server_port: 3000
+  app_port: 4000

data/spec/ringleader/config_spec.rb

@@ -15,8 +15,8 @@ describe Ringleader::Config do
         expect(config.dir).to eq("~/apps/main")
       end
 
-      it "includes a default hostname" do
-        expect(subject.apps["admin"].hostname).to eq("127.0.0.1")
+      it "includes a default host" do
+        expect(subject.apps["admin"].host).to eq("127.0.0.1")
       end
 
       it "includes a default idle timeout" do
@@ -41,4 +41,27 @@ describe Ringleader::Config do
     end
   end
 
+  context "with a config without an app port" do
+    it "raises an exception" do
+      expect {
+        Ringleader::Config.new("spec/fixtures/no_app_port.yml").apps
+      }.to raise_error(/app_port/)
+    end
+  end
+
+  context "with a config without a server port" do
+    it "raises an exception" do
+      expect {
+        Ringleader::Config.new("spec/fixtures/no_server_port.yml").apps
+      }.to raise_error(/server_port/)
+    end
+  end
+
+  context "with a config with an 'rvm' key instead of a 'command'" do
+    it "replaces the rvm command with a command to use rvm" do
+      config = Ringleader::Config.new "spec/fixtures/rvm.yml"
+      expect(config.apps["rvm_app"].command).to match(/rvm.*rvmrc.*exec.*foreman/)
+    end
+  end
+
 end