expedite 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 492f096e30142c23ad6849f79864355a96fdb042990d43aaaaa85516643a6338
-  data.tar.gz: 29d32100e9df804748a684fdce1636907fe844996adb702e193369c434ffcd8a
+  metadata.gz: d23f0d668e02d87588fa2838e18afe60ca22e42a6df958c28418a5e3629a596c
+  data.tar.gz: 99086610fca24d08680ca1824315b179e904b31aade25aba8365f0d0873d6ac5
 SHA512:
-  metadata.gz: d5f5fce18a565bbc3ea616bf1a5db621a1708eae3f6d1ce6ae6bb5c32d266859983ed35fefc8905184241602bc1554128627adf4ff3281f256056147351c9d2e
-  data.tar.gz: f85be9f1dfe698b1875fd0008d9a0c4ed324f5ddeb1b9562b83431864c4eaa664e1c83e748b680fb6877ecdd00c71a8160226613d52ae6f5338e7ec2195d7809
+  metadata.gz: 1e26f98230e95ae04828b9500f1e5e1dabd76296fa0d41a18ef55ea653e115b2283190ddfa706f1280e3bb78959e1ab9ab36f4d17ecd09b91f9a6c954ee06789
+  data.tar.gz: d46a15f0bf0bbf68e87a0cd58d4df5d9af7850c51619199d1006f6313b44c746f6d3188fc09bed1ef0cefa636a61671a1c283fa8201e0c9bbbf018a775618dac

data/README.md

@@ -8,20 +8,24 @@ derivatives to start faster.
 
 ## Usage
 
-Register variants and commands in `expedite_helper.rb`. For example:
+To use expedite you need to register variants and commands 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:
 ```
-Expedite::Variants.register('base' do |name|
-  puts "Base started"
+# 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
 end
 ```
 
-You can register variants that are based on other variants, and you can also have wildcard
+You can register variants that are based on other variants. You can also have wildcard
 matchers.
 ```
-Expedite::Variants.register('development/*', parent: 'base') do |name|
-  customer = File.basename(name)
-  puts "Starting development for #{customer}"
+Expedite::Variants.register('development/*', parent: 'parent') do |name|
+  $sleep_child = name
 end
 ```
 
@@ -37,7 +41,47 @@ Expedite::Commands.register("custom") do
 end
 ```
 
-Then you can execute a command in the variant using:
+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.
+
 ```
+require 'expedite'
+
 Expedite.v("development/abc").call("custom")
 ```
+
+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.
+
+```
+# bundle exec ./main.rb
+[development/abc] sleeping for 5
+$sleep_parent = 1
+$sleep_child = development/abc
+[development/abc] done
+```
+
+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
+
+To explicitly stop the server and all the variants, you use:
+
+```
+$ bundle exec expedite stop
+```
+
+You can also start the server in the foreground.
+
+```
+$ bundle exec expedite server
+```
+
+## Acknowledgements
+
+Expedite's server core is modified from [Spring](https://github.com/rails/spring)

data/lib/expedite/application.rb

@@ -6,8 +6,8 @@ require 'socket'
 require 'expedite/commands'
 require 'expedite/env'
 require 'expedite/failsafe_thread'
-require 'expedite/load_helper'
 require 'expedite/signals'
+require 'expedite/variants'
 
 module Expedite
   def self.variant
@@ -22,16 +22,14 @@ module Expedite
   end
 
   class Application
-    include LoadHelper
     include Signals
 
     attr_reader :variant
-    attr_reader :manager, :env, :original_env
+    attr_reader :manager, :env
 
-    def initialize(variant, manager, original_env, env = Env.new)
+    def initialize(variant:, manager:, env:)
       @variant      = variant
       @manager      = manager
-      @original_env = original_env
       @env          = env
       @mutex        = Mutex.new
       @waiting      = Set.new
@@ -48,7 +46,7 @@ module Expedite
 
       Signal.trap("TERM") { terminate }
 
-      load_helper
+      env.load_helper
       eager_preload if false #if ENV.delete("SPRING_PRELOAD") == "1"
       run
     end
@@ -149,9 +147,6 @@ module Expedite
         ARGV.replace(args)
         $0 = exec_name
 
-        # Delete all env vars which are unchanged from before Spring started
-        original_env.each { |k, v| ENV.delete k if ENV[k] == v }
-
         # Load in the current env vars, except those which *were* changed when Spring started
         env.each { |k, v| ENV[k] = v }
 
@@ -177,7 +172,12 @@ module Expedite
       log "forked #{pid}"
       manager.puts pid
 
-      wait pid, streams, client
+      # Boot makes a new application, so we don't wait for it
+      if command.is_a?(Expedite::Command::Boot)
+        Process.detach(pid)
+      else
+        wait pid, streams, client
+      end
     rescue Exception => e
       log "exception: #{e} at #{e.backtrace.join("\n")}"
       manager.puts unless pid

data/lib/expedite/application/boot.rb

@@ -1,9 +1,11 @@
 require "expedite/application"
 
 app = Expedite::Application.new(
-  ENV['EXPEDITE_VARIANT'],
-  UNIXSocket.for_fd(3),
-  {},
-  Expedite::Env.new(log_file: IO.for_fd(4))
+  variant: ENV['EXPEDITE_VARIANT'],
+  manager: UNIXSocket.for_fd(3),
+  env: Expedite::Env.new(
+    root: ENV['EXPEDITE_ROOT'],
+    log_file: IO.for_fd(4),
+  ),
 )
 app.boot

data/lib/expedite/application_manager.rb

@@ -9,18 +9,20 @@ module Expedite
   class ApplicationManager
     include SendJson
 
-    attr_reader :pid, :child, :variant, :env, :status
-
-    def initialize(variant, env)
-      @variant    = variant
-      @env        = env
-      @mutex      = Mutex.new
-      @state      = :running
-      @pid        = nil
+    attr_reader :pid, :child, :name, :env, :status, :variant
+
+    def initialize(name, env)
+      @name  = name
+      @env   = env
+      @mutex = Mutex.new
+      @state = :running
+      @pid   = nil
+
+      @variant = Expedite::Variants.lookup(@name)
     end
 
     def log(message)
-      env.log "[application_manager:#{variant}] #{message}"
+      env.log "[application_manager:#{name}] #{message}"
     end
 
     # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
@@ -98,8 +100,12 @@ module Expedite
       # Don't care
     end
 
+    def keep_alive
+      variant.keep_alive
+    end
+
     def parent
-      Expedite::Variants.lookup(variant).parent
+      variant.parent
     end
 
     private
@@ -121,7 +127,7 @@ module Expedite
       wr.send_io STDERR
       wr.send_io STDIN
 
-      send_json wr, 'args' => ['expedite/boot', variant], 'env' => {}
+      send_json wr, 'args' => ['expedite/boot', name], 'env' => {}
       wr.send_io child_socket
       wr.send_io env.log_file
       wr.close
@@ -139,7 +145,8 @@ module Expedite
         bundler_dir = File.expand_path("../..", $LOADED_FEATURES.grep(/bundler\/setup\.rb$/).first)
         @pid = Process.spawn(
           {
-            "EXPEDITE_VARIANT" => variant,
+            "EXPEDITE_VARIANT" => name,
+            "EXPEDITE_ROOT" => env.root,
           },
           "ruby",
           *(bundler_dir != RbConfig::CONFIG["rubylibdir"] ? ["-I", bundler_dir] : []),
@@ -171,7 +178,7 @@ module Expedite
         synchronize {
           if @pid == pid
             @pid = nil
-            restart
+            restart if keep_alive
           end
         }
       end

data/lib/expedite/cli.rb

@@ -31,6 +31,8 @@ module Expedite
 
     def run(args)
       command(args.first).run(args[1..])
+    rescue NotImplementedError
+      Cli::Help.new.run([])
     end
 
     def command(cmd)

data/lib/expedite/command/boot.rb

@@ -7,10 +7,12 @@ module Expedite
         require "expedite/application"
         
         Expedite::Application.new(
-          variant,
-          UNIXSocket.for_fd(@child_socket.fileno),
-          {},
-          Expedite::Env.new(log_file: @log_file)
+          variant: variant,
+          manager: UNIXSocket.for_fd(@child_socket.fileno),
+          env: Expedite::Env.new(
+            root: ENV['EXPEDITE_ROOT'],
+            log_file: @log_file,
+          ),
         ).boot
       end
 

data/lib/expedite/command/info.rb

@@ -25,10 +25,12 @@ module Expedite
         require "expedite/application"
 
         Expedite::Application.new(
-          variant,
-          UNIXSocket.for_fd(@child_socket.fileno),
-          {},
-          Expedite::Env.new(log_file: @log_file)
+          variant: variant,
+          manager: UNIXSocket.for_fd(@child_socket.fileno),
+          env: Expedite::Env.new(
+            root: ENV['EXPEDITE_ROOT'],
+            log_file: @log_file,
+          ),
         ).boot
       end
 

data/lib/expedite/env.rb

@@ -56,5 +56,17 @@ module Expedite
     def graceful_termination_timeout
       2
     end
+
+    def helper_path
+      Pathname.new(root).join("expedite_helper.rb")
+    end
+
+    def load_helper
+      path = helper_path
+      if path.exist?
+        log "loading #{path}"
+        load(path)
+      end
+    end
   end
 end

data/lib/expedite/server.rb

@@ -3,12 +3,10 @@ require 'json'
 require 'socket'
 require "expedite/application_manager"
 require "expedite/env"
-require 'expedite/load_helper'
 require "expedite/signals"
 
 module Expedite
   class Server
-    include LoadHelper
     include Signals
 
     def self.boot(options = {})
@@ -33,7 +31,7 @@ module Expedite
     end
 
     def boot
-      load_helper
+      env.load_helper
 
       write_pidfile
       set_pgid unless foreground?

data/lib/expedite/variants.rb

@@ -1,13 +1,23 @@
 
 module Expedite
   class Variant
+    ##
+    # Name of the parent variant. This allows you to create variants from
+    # an existing variant.
+    # Defaults to nil.
     attr_accessor :parent
 
+    ##
+    # If set to true, variant will be restarted automatically if it is killed.
+    # Defaults to false.
+    attr_accessor :keep_alive
+
     ##
     # [parent] Name of parent variant.
     # [after_fork] Block is executed when variant is first preloaded.
-    def initialize(parent: nil, &after_fork)
+    def initialize(parent: nil, keep_alive: false, &after_fork)
       @parent = parent
+      @keep_alive = keep_alive
       @after_fork_proc = after_fork
     end
 
@@ -82,7 +92,7 @@ module Expedite
     end
 
     def reset
-      @registrations = {}
+      @registrations = []
       nil
     end
   end

data/lib/expedite/version.rb

@@ -1,3 +1,3 @@
 module Expedite
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expedite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Bing-Chang Lai
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-12 00:00:00.000000000 Z
+date: 2021-07-03 00:00:00.000000000 Z
 dependencies: []
 description: Manages Ruby processes that can be used to spawn child processes faster.
 email: johnny.lai@me.com
@@ -34,7 +34,6 @@ files:
 - lib/expedite/env.rb
 - lib/expedite/errors.rb
 - lib/expedite/failsafe_thread.rb
-- lib/expedite/load_helper.rb
 - lib/expedite/send_json.rb
 - lib/expedite/server.rb
 - lib/expedite/signals.rb

data/lib/expedite/load_helper.rb

@@ -1,11 +0,0 @@
-module Expedite
-  module LoadHelper
-    def load_helper
-      helper = "expedite_helper.rb"
-      if File.exist?(helper)
-        log "loading #{helper}"
-        load(helper)
-      end
-    end
-  end
-end