pcelka 1.0.0

data/lib/pcelka/async_client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "async"
+require "pcelka/server"
+require "pcelka/spec"
+
+# Public interface to the Server. Server runs in the background,
+# and Client communicates with it.
+#
+# Example usage:
+#
+#     pcelka = Pcelka::AsyncClient.from_procfile procfile
+#     pcelka.server.writer.add_console_writer
+#     th = Thread.new { pcelka.server.run }
+#     pcelka << :start_all
+#     th.join
+#
+module Pcelka
+  class AsyncClient
+    def self.from_procfile(procfile)
+      spec = Spec.from_procfile(procfile)
+      client_sink = Async::Queue.new
+      mailbox = Async::Queue.new
+      programs_status_changed_cond = Async::Condition.new
+      read, write = IO.pipe
+      server = Server.new spec:, client_sink:, wakeup_io: read, mailbox:,
+        programs_status_changed_cond:;
+
+      new server:, client_sink:, wakeup_io: write, server_mailbox: mailbox,
+        programs_status_changed_cond:
+    end
+
+    attr_reader :server
+
+    def initialize(server:, client_sink:, wakeup_io:, server_mailbox:, programs_status_changed_cond:)
+      @server, @client_sink, @wakeup_io, @server_mailbox, @programs_status_changed_cond =
+        server, client_sink, wakeup_io, server_mailbox, programs_status_changed_cond
+    end
+
+    def <<(cmd)
+      @server_mailbox << cmd
+      @wakeup_io.putc Server::WAKEUP_BYTE
+      @client_sink.pop
+    rescue Errno::EPIPE
+      raise "Failed to write to @runner's pipe"
+    end
+
+    def programs_status_changed?
+      @programs_status_changed_cond.wait
+    end
+  end
+end

data/lib/pcelka/logs_collector.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative "../../db"
+
+module Pcelka
+  class LogsCollector
+    def initialize(logs_mailbox)
+      @logs_ready = Async::Condition.new
+      @logs_mailbox = logs_mailbox
+      @collect_thread = nil
+    end
+
+    def collect
+      @collect_thread = Thread.new do
+        while l = @logs_mailbox.pop
+          new_id = DB[:logs].insert(app: l[0], message: l[1], is_error: l[2])
+          @logs_ready.signal new_id
+        end
+      end
+    end
+
+    def retrieve_new_logs(last_id = 0)
+      logs = DB[:logs].order(:id).where{id > last_id}.all
+      unless logs.empty?
+        last_id = logs.last[:id]
+        logs.each{ yield it }
+      end
+
+      while @logs_ready.wait
+        logs = DB[:logs].order(:id).where{id > last_id}.all
+        unless logs.empty?
+          last_id = logs.last[:id]
+          logs.each{ yield it }
+        end
+      end
+    end
+  end
+end

data/lib/pcelka/program.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require "open3"
+
+# An executable program with common lifecycle methods. It is expected to
+# print something to standard output and standard error, and this is
+# captured for output by the Server.
+module Pcelka
+  class Program
+    attr_reader :id
+
+    def initialize(id:, cmd:, stdin:, stdout:, stderr:, thread:, cwd:)
+      @id, @cmd, @stdin, @stdout, @stderr, @thread, @cwd =
+        id, cmd, stdin, stdout, stderr, thread, cwd
+      @stdin.close
+      @stdout_ready = @stderr_ready = false
+      @stopping = false
+    end
+
+    def self.start_from_spec(spec)
+      Dir.chdir(spec.cwd) do
+        stdin, stdout, stderr, thread = Open3.popen3(spec.cmd)
+        new id: spec.id, cmd: spec.cmd, stdin:, stdout:, stderr:, thread:,
+          cwd: spec.cwd
+      end
+    rescue Errno::ENOENT
+      # From Procfile, we get all commands wrapped into `sh` so this error
+      # could only happen when `sh` is not found on the system. Could happen
+      # more often for other formats.
+      raise "Unknown command: '#{spec.cmd}'"
+    end
+
+    def alive? = !dead?
+    def dead? = !@thread.alive?
+    def stopping? = @stopping
+
+    def status
+      if alive? then :alive
+      elsif dead? then :dead
+      elsif stopping? then :stopping
+      else :unknown
+      end
+    end
+
+    def read_stdout
+      if @stdout_ready
+        @stdout_ready = false
+        @stdout.gets
+      end
+    end
+
+    def read_stderr
+      if @stderr_ready
+        @stderr_ready = false
+        @stderr.gets
+      end
+    end
+
+    def ios = [@stdout, @stderr]
+
+    def mark_ready(io)
+      if io == @stdout
+        @stdout_ready = true
+      elsif io == @stderr
+        @stderr_ready = true
+      end
+    end
+
+    def stop
+      if alive? && !@stopping
+        @stopping = true
+        @stdout.flush
+        @stderr.flush
+        Process.kill "SIGTERM", @thread.pid
+        @stopping = false
+      end
+    rescue Errno::ESRCH, Errno::EPERM
+    end
+  end
+end

data/lib/pcelka/server/commandable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "pcelka/server/controllable"
+require "pcelka/server/reportable"
+
+# Allow receiving commands and do corresponding actions.
+module Pcelka
+  class Server
+    module Commandable
+      include Reportable
+      include Controllable
+
+      private
+        def remove_wakeup_io(ios)
+          if ios.reject!{ it == @wakeup_io }
+            byte = @wakeup_io.readbyte
+            raise "Unexpected byte: #{byte}" unless byte == WAKEUP_BYTE
+            @is_pending_cmd = true
+          end
+        end
+
+        def process_cmd
+          return unless @is_pending_cmd
+          @is_pending_cmd = false
+
+          response =
+            case @mailbox.pop
+            in :start_all
+              @writer.write app: "_all", message: "_starting_all"
+              start_all
+            in :stop_all
+              @writer.write app: "_all", message: "_stopping_all"
+              stop_all
+            in [:start, id]
+              @writer.write app: id, message: "_starting"
+              start(id)
+            in [:stop, id]
+              @writer.write app: id, message: "_stopping"
+              stop(id)
+            in [:restart, id]
+              @writer.write app: id, message: "_restarting"
+              restart(id)
+            in :report
+              report
+            in :shutdown
+              warn "Pcelka shutting down..."
+              stop_all
+              @should_stop = true
+            else
+              :unknown
+            end
+
+          @client_sink << response
+        end
+    end
+  end
+end

data/lib/pcelka/server/controllable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "pcelka/program"
+
+# Controls the programs in the spec: start, stop, restart, etc.
+module Pcelka
+  class Server
+    module Controllable
+      def start(id)
+        unless @running_programs.find{ it.id == id }
+          program = Program.start_from_spec(@spec[id])
+          @running_programs << program
+          add_to_started_programs program
+          id
+        end
+      end
+
+      def start_all
+        @spec.filter_map{|id, _| start(id) }
+      end
+
+      def stop(id)
+        if program = @running_programs.find{ it.id == id }
+          @running_programs.reject!{ it.id == id }
+          program.stop
+          id
+        end
+      end
+
+      def stop_all
+        @running_programs.filter_map{ stop(it.id) }
+      end
+
+      def restart(id)
+        stop(id) && start(id)
+      end
+
+      private
+        def add_to_started_programs(program)
+          return unless defined?(@started_programs)
+
+          @started_programs.delete_if{ it.id == program.id } << program
+        end
+    end
+  end
+end

data/lib/pcelka/server/notifiable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pcelka
+  class Server
+    module Notifiable
+      private
+        def init_notifiable(programs_status_changed_cond:)
+          @programs_status_changed_cond = programs_status_changed_cond
+          @last_programs_statuses = nil
+        end
+
+        def notify_programs_status_changed
+          new_statuses = gather_statuses
+          if @last_programs_statuses.nil? || @last_programs_statuses != new_statuses
+            @programs_status_changed_cond.signal true
+          end
+          @last_programs_statuses = new_statuses
+        end
+
+        def gather_statuses
+          @started_programs.map{[it.id, it.status]}
+        end
+    end
+  end
+end

data/lib/pcelka/server/reportable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Provides a "state" of the server together with possible actions.
+module Pcelka
+  class Server
+    module Reportable
+      Report = Data.define(:items, :allowed_actions, :possible_actions)
+      ReportItem = Data.define(:id, :cmd, :status, :allowed_actions,
+        :possible_actions)
+
+      def report
+        items =
+          @spec.keys.sort.map do |id|
+            program_spec = @spec[id]
+            program = @started_programs.find{ it.id == id }
+            status = program_status(program)
+            ReportItem.new id:, cmd: program_spec.cmd, status:,
+              allowed_actions: allowed_program_actions(status),
+              possible_actions: PROGRAM_POSSIBLE_ACTIONS
+          end
+
+        Report.new items:, allowed_actions: allowed_server_actions(items),
+          possible_actions: SERVER_POSSIBLE_ACTIONS
+      end
+
+      private
+        def program_status(program)
+          program&.status || :not_started
+        end
+
+        SERVER_POSSIBLE_ACTIONS = %i[start_all stop_all].freeze
+        PROGRAM_POSSIBLE_ACTIONS = %i[start restart stop].freeze
+        NOT_STARTED_ACTIONS = %i[start].freeze
+        ALIVE_ACTIONS = %i[stop restart].freeze
+        DEAD_ACTIONS = %i[start].freeze
+        STOPPING_ACTIONS = [].freeze
+        UNKNOWN_ACTIONS = [].freeze
+        private_constant :NOT_STARTED_ACTIONS, :ALIVE_ACTIONS, :DEAD_ACTIONS,
+          :STOPPING_ACTIONS, :UNKNOWN_ACTIONS, :PROGRAM_POSSIBLE_ACTIONS,
+          :SERVER_POSSIBLE_ACTIONS
+
+        def allowed_program_actions(status)
+          case status
+          when :not_started then NOT_STARTED_ACTIONS
+          when :alive then ALIVE_ACTIONS
+          when :dead then DEAD_ACTIONS
+          when :stopping then STOPPING_ACTIONS
+          when :unknown then UNKNOWN_ACTIONS
+          else raise "Unreachable"
+          end
+        end
+
+        def allowed_server_actions(items)
+          allowed_actions = []
+          allowed_actions << :start_all if items.any?{ it.allowed_actions.include?(:start) }
+          allowed_actions << :stop_all if items.any?{ it.allowed_actions.include?(:stop) }
+          allowed_actions
+        end
+    end
+  end
+end

data/lib/pcelka/server/writing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "pcelka/writer"
+
+# Use the Writer class.
+module Pcelka
+  class Server
+    module Writing
+      attr_reader :writer
+
+      private
+        def init_writer
+          @writer = Writer.new
+        end
+
+        def write_programs_output(programs)
+          programs.each do |program|
+            if out = program.read_stdout
+              @writer.write app: program.id, message: out
+            end
+
+            if err = program.read_stderr
+              @writer.write app: program.id, message: err, is_error: true
+            end
+          end
+        end
+    end
+  end
+end

data/lib/pcelka/server.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "pcelka/server/writing"
+require "pcelka/server/commandable"
+require "pcelka/server/notifiable"
+
+# Runs several command line programs.
+module Pcelka
+  class Server
+    include Writing, Commandable, Notifiable
+
+    WAKEUP_BYTE = 1
+
+    # @param spec [Spec]
+    # @param client_sink [Object#<<]
+    # @param wakeup_io [IO#readbyte]
+    # @param mailbox [Object#pop] receives messages from clients.
+    # @param programs_status_changed_cond [Async::Condition]
+    def initialize(spec:, client_sink:, wakeup_io:, mailbox:, programs_status_changed_cond:)
+      @spec, @client_sink, @wakeup_io, @mailbox =
+        spec, client_sink, wakeup_io, mailbox
+      @running_programs = []
+      @started_programs = []
+      @watch_ios = []
+      @is_pending_cmd = false
+      @should_stop = false
+      init_writer
+      init_notifiable programs_status_changed_cond:
+    end
+
+    def run
+      until @should_stop
+        if ready_io = check_ready_io
+          remove_wakeup_io(ready_io[0])
+          programs = ready_programs(ready_io[0])
+          write_programs_output(programs)
+          process_cmd
+        end
+        notify_programs_status_changed
+        prune_dead_programs
+      end
+    end
+
+    private
+      def check_ready_io
+        ios_to_watch = @running_programs.flat_map(&:ios)
+        ios_to_watch << @wakeup_io
+        IO.select ios_to_watch, nil, nil, 0.1
+      end
+
+      def ready_programs(ios)
+        programs = ios.map{|io| @running_programs.find{ it.mark_ready(io) } }
+        programs.uniq!(&:id)
+        programs
+      end
+
+      def prune_dead_programs
+        @running_programs.filter! do |program|
+          next true if program.alive?
+          @writer.write app: program.id, message: "_died", is_error: true
+          program.stop
+          false
+        end
+      end
+  end
+end

data/lib/pcelka/spec/procfile.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "pcelka/spec/program_spec"
+
+# Parses Procfile.
+module Pcelka
+  class Spec
+    class Procfile
+      class InvalidFormat < StandardError; end
+
+      class << self
+        def parse_from_file(path)
+          pathname = Pathname.new(path)
+          raise ArgumentError, "No Procfile found at path '#{path}'" unless pathname.exist?
+
+          cwd = Pathname(path).dirname
+          parsed = []
+
+          pathname.each_line do |line|
+            next if line.start_with? "#"
+            id, cmd = line.split(":", 2)
+            raise InvalidFormat, "Line has invalid format: '#{line}'" if cmd.nil?
+            parsed << ProgramSpec.new(id:, cmd: parse_cmd(cmd), cwd:)
+          end
+
+          parsed
+        end
+
+        private
+          def parse_cmd(cmd)
+            envs, cmd_parts = cmd.split.partition{ it.include?("=") }
+            final_cmd = +""
+
+            if !envs.empty?
+              final_cmd << "env "
+              envs.each do |env|
+                final_cmd << env
+              end
+              final_cmd << " "
+            end
+
+            final_cmd << "sh -c '" << cmd_parts.join(" ") << "'"
+          end
+      end
+    end
+  end
+end

data/lib/pcelka/spec/program_spec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+# Specification to spawn the program from.
+ProgramSpec = Data.define(:id, :cmd, :cwd)

data/lib/pcelka/spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "pcelka/spec/procfile"
+
+# Public interface for different Spec providers.
+module Pcelka
+  class Spec
+    def self.from_procfile(path)
+      Procfile.parse_from_file(path).to_h{[it.id, it]}.freeze
+    end
+  end
+end

data/lib/pcelka/writer/console_writer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Writes possibly colored output to the console. Respencts the NO_COLOR
+# environment variable.
+module Pcelka
+  class Writer
+    class ConsoleWriter
+      ANSI = {
+        reset: 0, black: 30, red: 31, green: 32, yellow: 33, blue: 34,
+        magenta: 35, cyan: 36, white: 37, bright_black: 30, bright_red: 31,
+        bright_green: 32, bright_yellow: 33, bright_blue: 34,
+        bright_magenta: 35, bright_cyan: 36, bright_white: 37 }.freeze
+
+      COLORS = %i[
+        cyan yellow green magenta blue bright_cyan bright_yellow
+        bright_green bright_magenta bright_red bright_blue].freeze
+
+      ANSI_RESET = "\e[0m"
+      ANSI_ERROR = "\e[31m"
+
+      def initialize
+        @colors = {}
+      end
+
+      def write(app:, message:, is_error:)
+        log_line = +""
+        if is_error
+          log_line << colored{ANSI_ERROR} << "STDERR "
+        else
+          log_line << colored{ansi_color(app)}
+        end
+        log_line << app << ": " << colored{ANSI_RESET} << message
+        $stdout.write log_line
+        $stdout.flush
+      end
+
+      private
+        def ansi_color(app)
+          @colors[app] ||=
+            begin
+              color = COLORS[@colors.size % COLORS.size]
+              ansi = ANSI[color]
+              "\e[#{ansi}m"
+            end
+        end
+
+        def colored
+          no_color? ? "" : yield
+        end
+
+        def no_color?
+          return @no_color if defined?(@no_color)
+          return @no_color = true unless $stdout.isatty
+          no_color_env = ENV["NO_COLOR"]
+          return @no_color = true if no_color_env && !no_color_env.empty?
+          @no_color = false
+        end
+    end
+  end
+end

data/lib/pcelka/writer/generic_writer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Writes a structured message to an `Object#<<`.
+module Pcelka
+  class Writer
+    class GenericWriter
+      def initialize(sink)
+        @sink = sink
+      end
+
+      def write(app:, message:, is_error:)
+        @sink << [app, message, is_error]
+      end
+    end
+  end
+end

data/lib/pcelka/writer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require "pcelka/writer/console_writer"
+require "pcelka/writer/generic_writer"
+
+# Container for different concrete writers. Delegates writing to all
+# the @writers.
+module Pcelka
+  class Writer
+    def initialize
+      @writers = []
+    end
+
+    def add_console_writer
+      @writers << ConsoleWriter.new
+    end
+
+    def add_generic_writer(port)
+      @writers << GenericWriter.new(port)
+    end
+
+    def write(app:, message:, is_error: false)
+      @writers.each{ it.write(app:, message:, is_error:) }
+    end
+  end
+end

data/lib/pcelka.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pcelka
+  VERSION = "1.0.0"
+end

data/models.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative "db"
+
+# if %w"development test".include? ENV["RACK_ENV"]
+#   require "logger"
+#   LOGGER = Logger.new($stdout)
+#   LOGGER.level = Logger::FATAL if ENV["RACK_ENV"] == "test"
+#   DB.loggers << LOGGER
+# end
+
+if %w[development test].include? ENV["RACK_ENV"]
+  require "console"
+  Console.logger.fatal! if ENV["RACK_ENV"] == "test"
+  DB.loggers << Console
+end
+
+require "sequel/core"
+Sequel.extension :migration
+Sequel::Migrator.run(DB, "db/migrations")
+
+Sequel.extension :fiber_concurrency

data/pcelka.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require "async"
+require "pcelka/async_client"
+require "pcelka/logs_collector"
+
+procfile = Pathname(ENV.fetch("PCELKA_PROCFILE", "Procfile"))
+unless procfile.exist?
+  procfile = Pathname(__FILE__).parent.join("examples/procfile/Procfile")
+  Console.warn "Running an example proc!"
+  Console.warn "Please run in the directory with Procfile or specify it via the PCELKA_PROCFILE environment variable"
+end
+
+logs_mailbox = Async::Queue.new
+PCELKA = Pcelka::AsyncClient.from_procfile procfile
+PCELKA.server.writer.add_generic_writer logs_mailbox
+LOGS_COLLECTOR = Pcelka::LogsCollector.new logs_mailbox
+LOGS_COLLECTOR.collect
+
+Thread.new do
+  PCELKA.server.run
+  PCELKA << :start_all
+end