kirk 0.1.0-java → 0.1.5-java

data/README.md

@@ -14,9 +14,9 @@ retarded ruby rack server out there.
 Here is a brief highlight of some of the features available.
 
 * 0 Downtime deploys: Deploy new versions of your rack application without
-  losing a single request. The basic strategy is similar to Passenger.
-  Touch a magic file in the application root and Kirk will reload the
-  application without dropping a single request... It's just magic.
+  losing a single request. This happens atomically so it will work even under
+  heavy load. Also, if the redeploy fails for some reason (the application fails
+  to boot), then the previous application remains live.
 
 * Request body streaming: Have a large request body to handle? Why wait until
   receiving the entire thing before starting the work?
@@ -67,6 +67,21 @@ Once you have Kirk configured, start it up with the following command:
 
 ... and you're off.
 
+### Redeploying
+
+As showed above, one way to trigger a redeploy is to specify a magic file to
+watch and then touch it. While this is simple, it doesn't give you any insight
+into the process of the redeploy. If the redeploy fails, there is no feedback.
+
+Another way to deploy is by running `kirk redeploy -R /path/to/app/config.ru`
+
+    $ kirk redeploy -R /path/to/app/config.ru
+    Waiting for response...
+    Redeploying application...
+    Redeploy complete.
+
+... that was easy.
+
 ### Daemonizing Kirk
 
 Use your OS features. For example, write an upstart script or use

data/lib/kirk.rb

@@ -29,6 +29,7 @@ module Kirk
     autoload :DeployWatcher,  'kirk/applications/deploy_watcher'
     autoload :HotDeployable,  'kirk/applications/hot_deployable'
     autoload :Rack,           'kirk/applications/rack'
+    autoload :RedeployClient, 'kirk/applications/redeploy_client'
   end
 
   require 'kirk/builder'

data/lib/kirk/applications/deploy_watcher.rb

@@ -1,17 +1,31 @@
+require 'socket'
+
 module Kirk
   class Applications::DeployWatcher
     include Jetty::LifeCycle::Listener
 
-    def initialize
+    def initialize(unix_socket_path = nil)
       @apps, @magic_telephone, @workers = [], LinkedBlockingQueue.new, 0
-      @info   = {}
+      @unix_socket, @unix_socket_path = nil, unix_socket_path
+      @info = {}
+    end
+
+    def start
+      raise "Watcher already started" if @thread
+      connect_unix_socket_server
       @thread = Thread.new { run_loop }
       @thread.abort_on_exception = true
+      true
     end
 
     def stop
       @magic_telephone.put :halt
+
+      disconnect_unix_socket_server
+
       @thread.join
+      @thread = nil
+      true
     end
 
     def life_cycle_started(app)
@@ -29,9 +43,32 @@ module Kirk
 
   private
 
+    def connect_unix_socket_server
+      return unless @unix_socket_path
+
+      umask = File.umask
+      File.umask(0137)
+
+      if File.exist?(@unix_socket_path)
+        File.delete(@unix_socket_path)
+      end
+
+      @unix_socket = UNIXServer.new(@unix_socket_path)
+    ensure
+      File.umask(umask)
+    end
+
+    def disconnect_unix_socket_server
+      @unix_socket.close if @unix_socket
+      File.delete(@unix_socket_path) if @unix_socket_path
+    end
+
     def run_loop
       while true
-        # First, pull off messages
+        # First, check if there are any pending connections
+        handle_redeploys_on_socket
+
+        # Then, pull off messages
         while msg = @magic_telephone.poll(50, TimeUnit::MILLISECONDS)
           return if msg == :halt
           handle_message(*msg)
@@ -48,6 +85,41 @@ module Kirk
       cleanup
     end
 
+    def handle_redeploys_on_socket
+      return unless @unix_socket
+
+      conn = @unix_socket.accept_nonblock
+      line = conn.gets.chomp
+
+      if line =~ /^REDEPLOY (.*)$/
+        rackup_path = $1
+        app = @apps.find { |a| a.rackup_path == rackup_path }
+
+        unless app
+          conn.write "ERROR No application racked up at `#{rackup_path}`\n"
+          return
+        end
+
+        conn.write "INFO Redeploying application...\n"
+
+        if redeploy(app)
+          conn.write "INFO Redeploy complete.\n"
+        else
+          conn.write "ERROR Something went wrong\n"
+        end
+      else
+        conn.write "ERROR unknown command\n"
+      end
+    rescue Errno::EAGAIN,
+           Errno::EWOULDBLOCK,
+           Errno::ECONNABORTED,
+           Errno::EPROTO,
+           Errno::EINTR
+      # Nothing
+    ensure
+      conn.close if conn
+    end
+
     def handle_message(action, *args)
       case action
       when :watch
@@ -84,37 +156,48 @@ module Kirk
         new_last_modified = app.last_modified
         info = @info[app]
 
+        next unless new_last_modified
+
         if new_last_modified > info[:last_modified]
-          Kirk.logger.info("Reloading `#{app.application_path}`")
-          redeploy(app, new_last_modified)
+          Kirk.logger.info("Reloading `#{app.rackup_path}`")
+
+          # Redeploy the application
+          redeploy(app)
+
+          # Update the last modified time
+          info[:last_modified] = new_last_modified
         end
       end
     end
 
-    def redeploy(app, mtime)
-      if key = app.key
+    def redeploy(app)
+      ret = app.deploy(get_standby_deploy(app))
+      warmup_standby_deploy(app)
+      ret
+    end
 
-        queue  = @info[app][:standby]
-        deploy = queue.poll
+    def get_standby_deploy(app)
+      queue = @info[app][:standby]
+      key   = app.key
 
-        if deploy && deploy.key == key
-          app.deploy(deploy)
-        else
-          deploy.terminate if deploy
-          app.redeploy
-        end
+      return unless key
 
-        warmup_standby_deploy(app)
-      else
-        app.redeploy
+      while deploy = queue.poll
+        return deploy if deploy.key == key
+        # Otherwise, we don't need it anymore
+        background { deploy.terminate }
       end
-
-      @info[app][:last_modified] = mtime
     end
 
     def warmup_standby_deploy(app)
       queue = @info[app][:standby]
-      background { queue.put(app.build_deploy) }
+
+      return unless queue.size == 0
+
+      background do
+        deploy = app.build_deploy
+        queue.put deploy if deploy
+      end
     end
 
     def cleanup

data/lib/kirk/applications/hot_deployable.rb

@@ -7,7 +7,7 @@ module Kirk
 
       def initialize(config)
         super(config)
-        redeploy
+        deploy
       end
 
       def key
@@ -28,6 +28,10 @@ module Kirk
         config.application_path
       end
 
+      def rackup_path
+        config.rackup
+      end
+
       def last_modified
         mtimes = config.watch.map do |path|
           path = File.expand_path(path, application_path)
@@ -37,13 +41,24 @@ module Kirk
         mtimes.max
       end
 
-      def redeploy
-        deploy(build_deploy)
+      def deploy(deploy = nil)
+        deploy ||= build_deploy
+
+        if deploy
+          deploy.prepare
+          super(deploy)
+          true
+        end
+      rescue Exception => e
+        Kirk.logger.warning "Deploying `#{application_path}` failed: #{e.message}"
+        nil
       end
 
-      def deploy(d)
-        d.prepare
-        super(d)
+      def build_deploy
+        super
+      rescue Exception => e
+        Kirk.logger.warning "Warming up `#{application_path}` failed: #{e.message}"
+        nil
       end
     end
   end

data/lib/kirk/applications/redeploy_client.rb

@@ -0,0 +1,45 @@
+require 'socket'
+
+module Kirk
+  class Applications::RedeployClient
+    def self.redeploy(socket, path, &blk)
+      new(socket).redeploy(path, &blk)
+    end
+
+    def initialize(unix_socket_path)
+      @unix_socket, @unix_socket_path = nil, unix_socket_path
+    end
+
+    def redeploy(path, &blk)
+      connect
+      @unix_socket.write "REDEPLOY #{path}\n"
+      handle_response(&blk)
+    ensure
+      disconnect
+    end
+
+  private
+
+    def connect
+      @unix_socket = UNIXSocket.new(@unix_socket_path)
+    end
+
+    def disconnect
+      @unix_socket.close
+    end
+
+    def handle_response(&blk)
+      yield "Waiting for response..." if block_given?
+
+      while line = @unix_socket.gets
+        msg = case line
+        when /^INFO (.*)$/  then $1
+        when /^ERROR (.*)$/ then "[ERROR] #{$1}"
+        else "[ERROR] Received unknown message: `#{line}`"
+        end
+
+        yield msg if block_given?
+      end
+    end
+  end
+end

data/lib/kirk/builder.rb

@@ -12,18 +12,24 @@ module Kirk
       @root    = root || Dir.pwd
       @current = nil
       @configs = []
-      @options = { :watcher => Applications::DeployWatcher.new }
+      @options = {
+        :watcher => Applications::DeployWatcher.new("/tmp/kirk.sock")
+      }
     end
 
-    def load(path)
-      path = expand_path(path)
+    def load(glob)
+      glob = expand_path(glob)
 
-      with_root File.dirname(path) do
-        unless File.exist?(path)
-          raise MissingConfigFile, "config file `#{path}` does not exist"
-        end
+      files = Dir[glob].select { |f| File.file?(f) }
+
+      if files.empty?
+        raise MissingConfigFile, "glob `#{glob}` did not match any files"
+      end
 
-        instance_eval(File.read(path), path)
+      files.each do |file|
+        with_root File.dirname(file) do
+          instance_eval(File.read(file), file)
+        end
       end
     end
 
@@ -125,7 +131,7 @@ module Kirk
     def new_config
       Applications::Config.new.tap do |config|
         config.listen         = '0.0.0.0:9090'
-        config.watch          = [ 'REVISION' ]
+        config.watch          = [ ]
         config.bootstrap_path = File.expand_path('../bootstrap.rb', __FILE__)
       end
     end

data/lib/kirk/cli.rb

@@ -9,15 +9,13 @@ module Kirk
 
     def initialize(argv)
       @argv    = argv.dup
+      @command = nil
       @options = default_options
     end
 
     def run
       parse!
-
-      server = Kirk::Server.build(config)
-      server.start
-      server.join
+      send(command_handler)
     rescue Exception => e
       abort "[ERROR] #{e.message}"
     end
@@ -28,6 +26,33 @@ module Kirk
       @options[:config]
     end
 
+    def commands
+      [ 'start', 'redeploy' ]
+    end
+
+    def command_handler
+      "handle_#{@command}"
+    end
+
+    def handle_start
+      server = Kirk::Server.build(config)
+      server.start
+      server.join
+    end
+
+    def handle_redeploy
+      rackup = File.expand_path(@options[:rackup] || "#{Dir.pwd}/config.ru")
+      client = Applications::RedeployClient.new('/tmp/kirk.sock')
+
+      unless File.exist?(rackup)
+        raise MissingRackupFile, "rackup file `#{rackup}` does not exist"
+      end
+
+      client.redeploy(rackup) do |log|
+        puts log
+      end
+    end
+
     def default_options
       { :config => "#{Dir.pwd}/Kirkfile" }
     end
@@ -36,17 +61,32 @@ module Kirk
       @parser ||= OptionParser.new do |opts|
         opts.banner = "Usage: kirk [options] <command> [<args>]"
 
+        opts.separator ""
+        opts.separator "The available Kirk commands are:"
+        opts.separator "   start      Start up Kirk"
+        opts.separator "   redeploy   Redeploy a specific application"
+
         opts.separator ""
         opts.separator "Server options:"
 
-        opts.on("-c", "--config FILE",  "Load options from a config file") do |file|
+        opts.on("-c", "--config FILE", "Load options from a config file") do |file|
           @options[:config] = file
         end
+
+        opts.on("-R", "--rackup FILE", "Specify a rackup file") do |file|
+          @options[:rackup] = file
+        end
+
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          exit!
+        end
       end
     end
 
     def parse!
       parser.parse! @argv
+      @command = @argv.shift || "start"
     end
   end
 end

data/lib/kirk/server.rb

@@ -36,6 +36,8 @@ module Kirk
     end
 
     def start
+      watcher.start if watcher
+
       @server = Jetty::Server.new.tap do |server|
         connectors.each do |conn|
           server.add_connector(conn)

data/lib/kirk/version.rb

@@ -1,4 +1,4 @@
 module Kirk
   NAME    = "kirk".freeze
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.5".freeze
 end

metadata

@@ -2,7 +2,7 @@
 name: kirk
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.1.5
 platform: java
 authors: 
   - Carl Lerche
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-02 00:00:00 -08:00
+date: 2011-02-07 00:00:00 -08:00
 default_executable: kirk
 dependencies: []
 
@@ -41,6 +41,7 @@ files:
   - lib/kirk/applications/deploy_watcher.rb
   - lib/kirk/applications/hot_deployable.rb
   - lib/kirk/applications/rack.rb
+  - lib/kirk/applications/redeploy_client.rb
   - lib/rack/handler/kirk.rb
   - lib/kirk/native.jar
   - lib/kirk/jetty/jetty-server-7.2.2.v20101205.jar