expedite 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d23f0d668e02d87588fa2838e18afe60ca22e42a6df958c28418a5e3629a596c
-  data.tar.gz: 99086610fca24d08680ca1824315b179e904b31aade25aba8365f0d0873d6ac5
+  metadata.gz: 7c3af01b23cd76fd62beb91411f18fd9535c49cca41b530496f2031abc294b67
+  data.tar.gz: 260e78502a54f80f3c101f0880a79f738d68bf414adc401253d5cfec0a2837b9
 SHA512:
-  metadata.gz: 1e26f98230e95ae04828b9500f1e5e1dabd76296fa0d41a18ef55ea653e115b2283190ddfa706f1280e3bb78959e1ab9ab36f4d17ecd09b91f9a6c954ee06789
-  data.tar.gz: d46a15f0bf0bbf68e87a0cd58d4df5d9af7850c51619199d1006f6313b44c746f6d3188fc09bed1ef0cefa636a61671a1c283fa8201e0c9bbbf018a775618dac
+  metadata.gz: 0b0fdaa31cf55dd0fde167748208e5f1f1be5b8cb1b2def68cae75516df458614855e4c1c2bb4affec937dc7d7c43c4d8f04bb830998ff5c9ab7d6c6b65bf9e7
+  data.tar.gz: d59acca092ec657cadc977c2af264cf811b4cf1b601e5bd8074bd21d91424b3fc07e81930bde3443bdce51e05965541dd132a819a1d5fa4812f6fd32b0809b95

data/README.md

@@ -8,69 +8,76 @@ derivatives to start faster.
 
 ## Usage
 
-To use expedite you need to register variants and commands in an `expedite_helper.rb`
+To use expedite you need to define agents and actions in an `expedite_helper.rb`
 that is placed in the root directory of your application. The sample discussed
 in this section is in the [examples/simple](examples/simple) folder.
 
-This is the "parent" variant:
+This is the "parent" agent:
 ```
-# You can pass `keep_alive: true` if you want the variant to restart
-# automatically if it is terminated. This option defaults to false.
-Expedite::Variants.register('parent') do
-  $sleep_parent = 1
+Expedite.define do
+  agent :parent do
+    $parent_var = 1
+  end
 end
 ```
 
-You can register variants that are based on other variants. You can also have wildcard
+You can define agents that are based on other agents. You can also have wildcard
 matchers.
+
 ```
-Expedite::Variants.register('development/*', parent: 'parent') do |name|
-  $sleep_child = name
+Expedite.define do
+  agent "development/*", parent: :parent do |name|
+    $development_var = name
+  end
 end
 ```
 
-You register commands by creating classes in the `Expedite::Command` module. For example,
-this defines a `custom` command.
+The following defines an `info` action.
 
 ```
-Expedite::Commands.register("custom") do
-  puts "[#{Expedite.variant}] sleeping for 5"
-  puts "$sleep_parent = #{$sleep_parent}"
-  puts "$sleep_child = #{$sleep_child}"
-  puts "[#{Expedite.variant}] done"
+Expedite.define do
+  action :info do
+    puts "     Process.pid = #{Process.pid}"
+    puts "    Process.ppid = #{Process.ppid}"
+    puts "     $parent_var = #{$parent_var}"
+    puts "$development_var = #{$development_var}"
+  end
 end
 ```
 
-After registering your variant and commands, you can then use it. In the simple
-example, the `main.rb` calls the `custom` command on the `development/abc`
-variant.
+After defining your agents and actions, you can then use it. In the simple
+example, the `main.rb` calls the `info` command on the `development/abc`
+agent.
 
+The `invoke` method will execute the action, and return the result. There
+is also an `exec` method that will replace the current executable with
+the action; in that case, the return result is the exit code.
 ```
 require 'expedite'
 
-Expedite.v("development/abc").call("custom")
+Expedite.agent("development/abc").invoke("info")
 ```
 
 When you run `main.rb`, the following output is produced. Note that `$sleep_parent`
-comes from teh `parent` variant, and `$sleep_child` comes from the `development/abc`
-variant.
+comes from teh `parent` agent, and `$sleep_child` comes from the `development/abc`
+agent.
 
 ```
 # bundle exec ./main.rb
-[development/abc] sleeping for 5
-$sleep_parent = 1
-$sleep_child = development/abc
-[development/abc] done
+     Process.pid = 3855
+    Process.ppid = 3854
+     $parent_var = 1
+$development_var = development/abc
 ```
 
 Calling `main.rb` automatically started the expedite server in the background.
 In the above example, it does the following:
 
-1. Launch the `base` variant
-2. Fork from the `base` variant to create the `development/abc` variant
-3. Fork from the `development/abc` variant
+1. Launch the `parent` agent.
+2. Fork from the `parent` agent to create the `development/abc` agent.
+3. Fork from the `development/abc` agent to run the `info` command, and then quit.
 
-To explicitly stop the server and all the variants, you use:
+To explicitly stop the server and all the agents, you use:
 
 ```
 $ bundle exec expedite stop

data/lib/expedite/{command/basic.rb → action/block.rb}

@@ -1,7 +1,7 @@
 
 module Expedite
-  module Command
-    class Basic
+  module Action
+    class Block
       attr_reader :runs_in
       
       def initialize(runs_in: :application, &block)

data/lib/expedite/{command → action}/boot.rb

@@ -1,13 +1,13 @@
 module Expedite
-  module Command
+  module Action
     class Boot
-      def call
-        variant = ARGV[0]
+      def call(*args)
+        agent = args[0]
 
-        require "expedite/application"
+        require "expedite/server/agent"
         
-        Expedite::Application.new(
-          variant: variant,
+        Expedite::Server::Agent.new(
+          agent: agent,
           manager: UNIXSocket.for_fd(@child_socket.fileno),
           env: Expedite::Env.new(
             root: ENV['EXPEDITE_ROOT'],

data/lib/expedite/{commands.rb → actions.rb}

@@ -1,10 +1,10 @@
-require 'expedite/command/basic'
-require 'expedite/command/boot'
+require 'expedite/action/block'
+require 'expedite/action/boot'
 
 module Expedite
-  class Commands
+  class Actions
     def self.current
-      @current ||= Commands.new
+      @current ||= Actions.new
     end
 
     def self.lookup(name)
@@ -12,16 +12,16 @@ module Expedite
     end
 
     ##
-    # Registers a command. If multiple commands are registered with the
+    # Registers an action. If multiple actions are registered with the
     # same name, the last one takes precedence.
     #
-    # [name] Name of the command. Expedite internal commands are prefixed
+    # [name] Name of the action. Expedite internal actions are prefixed
     #        with "expedite/"
-    # [klass_or_nil] Class of the command. If omitted, will default to
-    #                Expedite::Command::Basic.
-    # [named_options] Command options. Passed to the initializer.
+    # [klass_or_nil] Class of the action. If omitted, will default to
+    #                Expedite::Action::Block.
+    # [named_options] Action options. Passed to the initializer.
     def self.register(name, klass_or_nil = nil, **named_options, &block)
-      self.current.register(name, klass_or_nil, **named_options, &block)
+      self.current.register(name.to_s, klass_or_nil, **named_options, &block)
     end
 
     ##
@@ -36,13 +36,13 @@ module Expedite
 
     def lookup(name)
        ret = @registrations[name]
-       raise NotImplementedError, "Command #{name.inspect} not found" if ret.nil?
+       raise NotImplementedError, "Action #{name.inspect} not found" if ret.nil?
        ret
     end
 
     def register(name, klass_or_nil = nil, **named_options, &block)
       cmd = if klass_or_nil.nil?
-        Command::Basic.new(**named_options, &block)
+        Action::Block.new(**named_options, &block)
       else
         klass_or_nil.new(**named_options)
       end
@@ -54,7 +54,7 @@ module Expedite
       @registrations = {}
 
       # Default registrations
-      register("expedite/boot", Expedite::Command::Boot)
+      register("expedite/boot", Expedite::Action::Boot)
 
       nil
     end

data/lib/expedite/agents.rb

@@ -0,0 +1,101 @@
+
+module Expedite
+  # Definition of a Agent
+  class Agent
+    ##
+    # Name of the parent agent. This allows you to create agents from
+    # an existing agent.
+    # Defaults to nil.
+    attr_accessor :parent
+
+    ##
+    # If set to true, agent will be restarted automatically if it is killed.
+    # Defaults to false.
+    attr_accessor :keep_alive
+
+    ##
+    # [parent] Name of parent agent.
+    # [keep_alive] Specifies if the agent should be automatically restarted if it is terminated. Defaults to false.
+    # [after_fork] Block is executed when agent is first preloaded.
+    def initialize(parent: nil, keep_alive: false, &after_fork)
+      @parent = parent
+      @keep_alive = keep_alive
+      @after_fork_proc = after_fork
+    end
+
+    ##
+    # Called when agent if first preloaded. This version calls the after_fork
+    # block provided in the initializer.
+    def after_fork(agent)
+      @after_fork_proc&.call(agent)
+    end
+  end
+
+  class Agents
+    Registration = Struct.new(:matcher, :agent) do
+      def match?(name)
+        File.fnmatch?(matcher, name.to_s)
+      end
+    end
+
+    def self.current
+      @current ||= Agents.new
+    end
+
+    ##
+    # Retrieves the specified agent
+    def self.lookup(agent)
+      self.current.lookup(agent.to_s)
+    end
+
+    ##
+    # Registers a agent. Agents are matched in the
+    # order they are registered.
+    #
+    # [matcher] Wildcard to match a name against.
+    # [named_options] Agent options.
+    # [after_fork] Optional block that is called when
+    #              agent is preloaded.
+    #
+    # = Example
+    #   Expedite::Agents.register('base' do |name|
+    #     puts "Base #{name} started"
+    #   end
+    #   Expedite::Agents.register('development/abc', parent: 'base') do |name|
+    #     puts "Agent #{name} started"
+    #   end
+    def self.register(matcher, **named_options, &after_fork)
+      self.current.register(matcher.to_s, **named_options, &after_fork)
+    end
+
+    ##
+    # Resets registrations to default
+    def self.reset
+      self.current.reset
+    end
+
+    def initialize
+      @registrations = []
+    end
+
+    def lookup(agent)
+      ret = @registrations.find do |r|
+        r.match?(agent)
+      end
+      raise NotImplementedError, "Agent #{agent.inspect} not found" if ret.nil?
+      ret.agent
+    end
+
+    def register(matcher, **named_options, &after_fork)
+      @registrations << Registration.new(
+        matcher,
+        Agent.new(**named_options, &after_fork)
+      )
+    end
+
+    def reset
+      @registrations = []
+      nil
+    end
+  end
+end

data/lib/expedite/cli/server.rb

@@ -2,9 +2,9 @@ module Expedite
   module Cli
     class Server
       def run(args)
-        require 'expedite/server'
+        require 'expedite/server/controller'
 
-        server = Expedite::Server.new(foreground: true)
+        server = Expedite::Server::Controller.new(foreground: true)
         server.boot
       end
 

data/lib/expedite/cli/status.rb

@@ -0,0 +1,34 @@
+# Based on https://github.com/rails/spring/blob/master/lib/spring/client/status.rb
+require 'expedite'
+require 'expedite/cli/server'
+require 'expedite/cli/stop'
+
+module Expedite
+  module Cli
+    class Status
+      def run(args)
+        require 'expedite/server/controller'
+
+        ctrl = Expedite::Server::Controller.new(foreground: true)
+        if ctrl.running?
+          puts "Expedite is running (pid=#{ctrl.pid})"
+          puts
+          print_process ctrl.pid
+          Expedite.agent("__server__").invoke("application_pids").each do |pid|
+            print_process pid
+          end
+        else
+          puts "Expedite is not running"
+        end
+      end
+
+      def summary
+        'Expedite server status'
+      end
+
+      def print_process(pid)
+        puts `ps -p #{pid} -o pid= -o command=`
+      end
+    end
+  end
+end

data/lib/expedite/cli/stop.rb

@@ -2,10 +2,10 @@ module Expedite
   module Cli
     class Stop
       def run(args)
-        require 'expedite/server'
+        require 'expedite/server/controller'
 
-        server = Expedite::Server.new
-        server.stop
+        ctrl = Expedite::Server::Controller.new
+        ctrl.stop
       end
 
       def summary

data/lib/expedite/cli.rb

@@ -1,4 +1,5 @@
 require 'expedite/cli/server'
+require 'expedite/cli/status'
 require 'expedite/cli/stop'
 
 module Expedite
@@ -26,6 +27,7 @@ module Expedite
     COMMANDS = {
       'help'   => Cli::Help,
       'server' => Cli::Server,
+      'status' => Cli::Status,
       'stop'   => Cli::Stop,
     }
 

data/lib/expedite/client/exec.rb

@@ -0,0 +1,124 @@
+
+# Based on https://github.com/rails/spring/blob/master/lib/spring/client/run.rb
+
+require 'bundler'
+require 'rbconfig'
+require 'socket'
+
+require 'expedite/client/invoke'
+require 'expedite/env'
+require 'expedite/errors'
+require 'expedite/protocol'
+
+module Expedite
+  module Client
+    class Exec < Invoke
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO WINCH) & Signal.list.keys
+
+      def initialize(env: nil, agent: nil)
+        super
+
+        @signal_queue  = []
+      end
+
+      def call(*args)
+        @args = args
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
+          cold_run
+        else
+          warm_run
+        end
+      ensure
+        server.close if server
+      end
+
+      def warm_run
+        run
+      rescue CommandNotFound
+        raise
+        require "expedite/command"
+
+        if Expedite.command(args.first)
+          # Command installed since Expedite started
+          stop_server
+          cold_run
+        else
+          raise
+        end
+      end
+
+      def cold_run
+        boot_server
+        connect
+        run
+      end
+
+      def run
+        status = perform(*@args)
+
+        exit status.to_i
+      rescue Errno::ECONNRESET
+        exit 1
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        if server_version != env.version
+          $stderr.puts "There is a version mismatch between the Expedite client " \
+                         "(#{env.version}) and the server (#{server_version})."
+
+          if server_booted?
+            $stderr.puts "We already tried to reboot the server, but the mismatch is still present."
+            exit 1
+          else
+            $stderr.puts "Restarting to resolve."
+            stop_server
+            cold_run
+          end
+        end
+      end
+
+      def queue_signals
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { @signal_queue << sig }
+        end
+      end
+
+      def suspend_resume_on_tstp_cont(pid)
+        trap("TSTP") {
+          log "suspended"
+          Process.kill("STOP", pid.to_i)
+          Process.kill("STOP", Process.pid)
+        }
+        trap("CONT") {
+          log "resumed"
+          Process.kill("CONT", pid.to_i)
+        }
+      end
+
+      def forward_signals(application)
+        @signal_queue.each { |sig| kill sig, application }
+
+        FORWARDED_SIGNALS.each do |sig|
+          trap(sig) { forward_signal sig, application }
+        end
+      end
+
+      def forward_signal(sig, application)
+        if kill(sig, application) != 0
+          # If the application process is gone, then don't block the
+          # signal on this process.
+          trap(sig, 'DEFAULT')
+          Process.kill(sig, Process.pid)
+        end
+      end
+
+      def kill(sig, application)
+        application.puts(sig)
+        application.gets.to_i
+      end
+    end
+  end
+end

data/lib/expedite/client/invoke.rb

@@ -0,0 +1,155 @@
+require 'socket'
+
+require 'expedite/env'
+require 'expedite/errors'
+require 'expedite/protocol'
+
+module Expedite
+  module Client
+    class Invoke
+      CONNECT_TIMEOUT   = 1
+      BOOT_TIMEOUT      = 20
+
+      attr_reader :args, :env, :agent
+      attr_reader :server
+
+      def initialize(env: nil, agent: nil)
+        @env = env || Env.new
+        @agent = agent
+
+        @server_booted = false
+      end
+
+      def call(*args)
+        begin
+          connect
+        rescue Errno::ENOENT, Errno::ECONNRESET, Errno::ECONNREFUSED
+          boot_server
+          connect
+        end
+
+        perform(*args)
+      ensure
+        server.close if server
+      end
+
+      def perform(*args)
+        verify_server_version
+
+        agent, client = UNIXSocket.pair
+        connect_to_agent(client, args)
+        run_command(client, agent, args)
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        raise ArgumentError, "Server mismatch. Expected #{env.version}, got #{server_version}." if server_version != env.version
+      end
+
+      def connect_to_agent(client, args)
+        server.send_io client
+
+        server.send_object("args" => args, "agent" => agent)
+
+        if IO.select([server], [], [], CONNECT_TIMEOUT)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Expedite server"
+        end
+      end
+
+      def run_command(client, agent, args)
+        log "sending command"
+
+        agent.send_io STDOUT
+        agent.send_io STDERR
+        agent.send_io STDIN
+
+        agent.send_object("args" => args, "env" => ENV.to_hash)
+
+        pid = server.gets
+        pid = pid.chomp if pid
+
+        # We must not close the client socket until we are sure that the application has
+        # received the FD. Otherwise the FD can end up getting closed while it's in the server
+        # socket buffer on OS X. This doesn't happen on Linux.
+        client.close
+
+        if pid && !pid.empty?
+          log "got pid: #{pid}"
+
+          ## suspend_resume_on_tstp_cont(pid)
+
+          ## forward_signals(application)
+          result = agent.recv_object
+          if result.key?("exception")
+            e = result["exception"]
+            log "got exception #{e}"
+            raise e
+          end
+
+          ret = result["return"]
+          log "got return value #{ret}"
+          return ret
+        else
+          log "got no pid"
+          raise UnknownError, "got no pid"
+        end
+      ensure
+        agent.close
+      end
+
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+
+        pid     = Process.spawn(gem_env, env.server_command, out: File::NULL)
+        timeout = Time.now + BOOT_TIMEOUT
+
+        @server_booted = true
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+
+          if status
+            # Server did not start
+            raise ArgumentError, "Server exited: #{status.exitstatus}"
+          elsif Time.now > timeout
+            $stderr.puts "Starting Expedite server with `#{env.server_command}` " \
+                         "timed out after #{BOOT_TIMEOUT} seconds"
+            exit 1
+          end
+
+          sleep 0.1
+        end
+      end
+
+      def server_booted?
+        @server_booted
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
+      def connect
+        @server = UNIXSocket.open(env.socket_path)
+      end
+
+      def gem_env
+        bundle = Bundler.bundle_path.to_s
+        paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
+
+        {
+          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
+          "GEM_HOME" => bundle
+        }
+      end
+    end
+  end
+end

data/lib/expedite/env.rb

@@ -1,6 +1,7 @@
 require 'digest'
 require 'pathname'
 require 'expedite/version'
+require 'expedite/server/agent_manager'
 
 module Expedite
   class Env
@@ -18,7 +19,7 @@ module Expedite
 
       env = self
       @applications = Hash.new do |h, k|
-        h[k] = ApplicationManager.new(k, env)
+        h[k] = Server::AgentManager.new(k, env)
       end
     end