webdevreloader 0.5

data/README

@@ -0,0 +1,50 @@
+Smart web application reloader
+------------------------------
+
+This is simple http request forwarder that checks your application
+sources for changes and transparently restarts it if there are any.
+
+It works with any web technology and provides development convenience
+similar (but superior) to Rails development mode reloading.
+
+Make your source change and than simply hit reload button. Reloader
+will notice change and will transparently restart your application.
+
+Usage
+-----
+
+Upstream port (the one you should point your broswer to) is controlled
+by -u option. Downstream port where your application server listens is
+controlled by -d option. You can pass file patterns to check for
+changes by -w options. Rest of command line arguments are interpreted
+as a command to run your application.
+
+By default reloader kills application even when there is active
+request execution. You can pass '--kill-gently' to make it wait active
+requests completion before killing application. This usually matters
+only for applications that use push.
+
+All options has defaults suitable for Rails applications. In this case
+just use command 'reloader ./script/server'. But remember to point
+your browser to port 8080, not 3000. You should also turn off Rails
+development mode reloading by setting config.cache_classes to true.
+
+Other cases need suitable options. For example I use the following
+command line to run ns_server which is erlang application:
+
+reloader -T 30 -s TERM -u 3000 -d 8080 -w '**/*.erl' -w '**/*.js' -- sh -c 'make -j3 fast-rebuild && ./start_shell.sh -noshell'
+
+This command forwards port 3000 to port 8080 (erlang server binds to
+8080). It also checks mtimes of all erlang (*.erl) and javascript
+(*.js) sources.
+
+As you can see you can easily invoke make to (re)build
+application. Also note that your application is run as background
+process group, so it should not try to read stdin. I pass -noshell to
+erlang to avoid that.
+
+
+License
+-------
+
+GPLv3. See COPYING.

data/bin/reloader

@@ -0,0 +1,536 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require 'socket'
+require 'optparse'
+require 'thread'
+require 'fcntl'
+
+require "rubygems"
+require "xray/thread_dump_signal_handler" rescue nil
+
+require 'io/wait'
+
+module Kernel
+  def p_log(category, message, *extra)
+    return if category.to_s =~ /_v$/ # suppress verbose messages
+    return if category == :downstream && message =~ /^got something/
+    return if category == :http
+    STDOUT.print Thread.current.object_id, ": "
+    STDOUT.print category, ": "
+    STDOUT.print message
+    ex = extra.map {|e| e.inspect}.join(", ")
+    STDOUT.puts ex
+  end
+end
+
+class Exception
+  def diagnose
+    class_str = self.class.to_s
+    out = "" << self.backtrace[0] << ": " << class_str
+    unless self.message.empty? || self.message == class_str
+      out << ": " << message
+    end
+    out << "\n\t" << self.backtrace[1..-1].join("\n\t") << "\n"
+  end
+end
+
+class Thread
+  def self.run_diag(except = nil, &block)
+    Thread.new do
+      begin
+        block.call
+      rescue Exception
+        unless except === $!
+          p_log :thread_diag, $!.diagnose
+        end
+        raise
+      end
+    end
+  end
+end
+
+# simple recursive (for readers) rwlock that prefers writers over
+# readers
+class RWLock
+  def initialize
+    @mutex = Mutex.new
+    @state = :free
+    @shared_q = ConditionVariable.new
+    @shared_counter = 0
+    @exclusive_q = ConditionVariable.new
+
+    @exclusive_requests = 0
+  end
+
+  def take_shared
+    @mutex.synchronize do
+      while true
+        if @exclusive_requests == 0
+          case @state
+          when :free, :shared
+            @shared_counter += 1
+            @state = :shared
+            return
+          end
+        end
+
+        p_log :lock, "sleeping for shared lock"
+        @shared_q.wait(@mutex)
+      end
+    end
+  end
+
+  def release_shared
+    @mutex.synchronize do
+      @shared_counter -= 1
+      @state = :free if @shared_counter == 0
+      @exclusive_q.signal
+    end
+  end
+
+  def take_exclusive
+    @mutex.synchronize do
+      @exclusive_requests += 1
+      while true
+        if @state == :free
+          @state = :exclusive
+          return
+        end
+
+        p_log :lock, "sleeping for x-lock. #{self.inspect}"
+        @exclusive_q.wait(@mutex)
+      end
+    end
+  end
+
+  def release_exclusive
+    @mutex.synchronize do
+      @exclusive_requests -= 1
+
+      @state = :free
+      if @exclusive_requests > 0
+        @exclusive_q.signal
+      else
+        @shared_q.signal
+      end
+    end
+  end
+
+  def cannot_raise
+    yield
+  rescue Exception
+    puts "BUG!"
+    raise
+  end
+
+  def synchronize_shared
+    take_shared
+    yield
+  ensure
+    cannot_raise do
+      release_shared
+    end
+  end
+
+  def synchronize_exclusive
+    take_exclusive
+    yield
+  ensure
+    cannot_raise do
+      release_exclusive
+    end
+  end
+end
+
+$gentle_killer = false
+
+$child_rd_pipe = nil
+$child_pgrp = nil
+
+$kill_signal = "KILL"
+
+$child_port = 3000
+$child_spawn_timeout = 30
+
+module ChildController
+  module_function
+
+  def port_busyness(port)
+    TCPSocket.new('127.0.0.1', port).close
+    true
+  rescue Errno::ECONNREFUSED
+    false
+  end
+
+  def poll_for_condition(timeout=5)
+    target = Time.now.to_f + timeout
+    begin
+      return if yield
+      sleep 0.05
+    end while (Time.now.to_f <= target)
+    raise Errno::ETIMEDOUT
+  end
+
+  def kill_child!(wait = false)
+    p_log :child, "killing child!"
+    Process.kill($kill_signal, -$child_pgrp) rescue nil
+    Process.kill($kill_signal, $child_pgrp) rescue nil
+    $child_pgrp, pid = nil, $child_pgrp
+    $child_rd_pipe.close rescue nil
+    $child_rd_pipe = nil
+    if wait
+      poll_for_condition do
+        !port_busyness($child_port)
+      end
+      begin
+        loop do
+          Process::waitpid(pid, Process::WNOHANG)
+        end
+      rescue Errno::ECHILD
+      end
+    end
+  end
+
+  def child_alife?
+    $child_rd_pipe.read_nonblock(1)
+    raise "Cannot happen"
+  rescue Errno::EAGAIN
+    true
+  rescue EOFError
+    false
+  end
+
+  def spawn_child!
+    p_log :child, "spawning child!"
+    $child_pgrp = nil
+    rd, wr = IO.pipe
+
+    sleeper_pid = nil
+    sleeper_pid = fork do
+      Process.setpgid(0, 0)
+      $0 = "sleeper: " + $0
+      Process.kill("STOP", 0)
+    end
+    Process.wait(sleeper_pid, Process::WUNTRACED)
+
+    $child_pgrp = fork do
+      Process.setpgid(Process.pid, sleeper_pid)
+      rd.close
+      STDIN.reopen("/dev/null")
+      begin
+        exec(*ARGV)
+      rescue Exception
+        puts "failed to exec: #{$!.inspect}"
+      end
+    end
+    
+    wr.close
+    $child_rd_pipe = rd
+    begin
+      Process.setpgid($child_pgrp, sleeper_pid)
+    rescue Errno::EACCESS
+    end
+    $child_pgrp = sleeper_pid
+    poll_for_condition($child_spawn_timeout) do
+      raise "The child exited before creating server socket" unless child_alife?
+      port_busyness($child_port)
+    end
+    p_log :child, "child is ready"
+  rescue Exception
+    if $child_pgrp
+      kill_child!
+    end
+    raise $!
+  end
+end
+
+at_exit do
+  p_log :child_v, "atexit!"
+  if $child_pgrp
+    ChildController.kill_child!
+  end
+end
+
+$interesting_files_patterns = ["vendor/**/*", "lib/**/*", "app/**/*", "config/**/*"]
+$mtimes = {}
+
+module DirWatcher
+  module_function
+
+  def collect_interesting_files!
+    mtimes = $mtimes = {}
+    names = $interesting_files_patterns.map {|p| Dir[p]}.flatten.sort.uniq
+    #  p_log :collect_interesting_files!, "names: ", names
+    names.each do |path|
+      st = begin
+             File.stat(path)
+           rescue Errno::ENOENT
+             next
+           end
+      next unless st.file?
+      mtimes[path] = st.mtime.to_i
+    end
+  end
+
+  def anything_changed?
+    $mtimes.each do |path, mtime|
+      st = begin
+             File.stat(path)
+           rescue Errno::ENOENT
+             return true
+           end
+      if st.mtime.to_i > mtime
+        p_log :child, "change detected on: ", path
+        return true
+      end
+    end
+    false
+  end
+end
+
+$socket_factory = lambda {TCPSocket.new('127.0.0.1', $child_port)}
+
+class Reloader
+  class << self
+    attr_accessor :socket_factory
+  end
+  self.socket_factory = $socket_factory
+
+  module Utils
+    if defined?(Fcntl::FD_CLOEXEC)
+      def set_cloexec(io)
+        io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      end
+    else
+      def set_cloexec(io)
+      end
+    end
+
+    HTTP_END_REQUEST_RE = /\r?\n\r?\n/m
+    HTTP_HEADER_END_RE = /\r?\n/m
+
+    def read_http_something(initial_data, io)
+      out = initial_data.dup
+      begin
+        io.readpartial(16384, out)
+        p_log :http, "got out: ", out
+        p_log :http_request, "req: ", out.split("\n").first.strip
+      end while out !~ HTTP_END_REQUEST_RE
+
+      offset = $~.begin(0)
+      request_length = $~.end(0)
+      request = out[0, offset]
+
+      headers = request.split(HTTP_HEADER_END_RE)
+      first_line = headers.shift
+      headers = headers.inject({}) do |h, line|
+        name, value = line.split(':', 2)
+        h[name.downcase.strip] = value.strip
+        h
+      end
+
+      # TODO: inspect other non-postable methods
+      if first_line =~ /^(GET |HEAD )/
+        return [out[0, request_length], out[request_length..-1]]
+      end
+
+      # transfer_coding = headers['transfer-coding']
+      # if transfer_coding
+      #   unless transfer_coding == 'chunked'
+      #     raise "unsupported transfer-coding: #{transfer_coding}"
+      #   end
+
+      #   while out[request_length..-1] !~ /([0-9A-Fa-f]+).*?\n\r?/ && request_length + 4096 < out.length
+      #     io.readpartial(16384, out)
+      #   end
+
+      #   raise "missing chunk-size" unless $~
+      #   request_length += $~.end
+      #   chunk_size = $1.to_i(16)
+      # # HERE
+      # end
+
+      if headers['content-length']
+        length = headers['content-length'].to_i
+        length += request_length
+        if out.size < length
+#          p_log :http, "reading: ", length - out.size
+          out << io.read(length - out.size)
+        end
+        raise if out.size < length
+        p_log :http, "out_diag: ", length, out.length
+        return [out[0,length].dup,
+                out[length..-1].dup]
+      end
+
+      while true
+        begin
+          io.readpartial(16384, out)
+        rescue EOFError
+          break
+        end
+      end
+
+      [out, ""]
+    rescue EOFError
+      return ["", out] if out.size == initial_data.size
+      raise "Partial request or response"
+    end
+  end
+
+  include Utils
+
+  class UpstreamConnection
+    include Utils
+
+    def initialize(socket, downstream)
+      @socket = socket
+      @downstream = downstream
+      @buffer = ""
+    end
+
+    def loop_iteration
+      request, @buffer = read_http_something(@buffer, @socket)
+      p_log :upstream_v, "out of read_http_something", request, @buffer
+      return :eof if request.empty?
+      @downstream.proxy_request(request)
+    end
+
+    def run
+      loop_iteration
+    ensure
+      close
+    end
+
+    def close
+      p_log :upstream, "closing"
+      @socket.close rescue nil
+      @downstream.close
+    end
+  end
+
+  class DownstreamConnection
+    include Utils
+
+    def initialize(socket, upstream_socket)
+      @socket = socket
+      @upstream_socket = upstream_socket
+    end
+
+    def proxy_request(request)
+      @socket << request
+      p_log :downstream, "sent request to downstream"
+
+      response, extra = read_http_something("", @socket)
+      if response.empty?
+        p_log :downstream, "downstream closed on in-flight request"
+        return :eof
+      end
+
+      p_log :downstream, "got something: #{response.inspect}"
+      raise unless extra.empty?
+
+      @upstream_socket << response
+    end
+
+    def close
+      return if @socket.closed?
+      @socket.close
+    end
+  end
+
+  def initialize(port=8080)
+    @server = TCPServer.new(port)
+    set_cloexec(@server)
+    @lock = RWLock.new
+  end
+
+  def check_dir!
+    p_log :child, "entering check_dir"
+    unless $child_pgrp
+      p_log :child, "no child running"
+      DirWatcher.collect_interesting_files!
+      ChildController.spawn_child!
+    end
+
+    p_log :child, "checking changes"
+    if DirWatcher.anything_changed?
+      p_log :child, "changed!"
+
+      if $gentle_killer
+        # We spawn shared lock takers, so we can release lock right away
+        # Taking lock ensures that every in-progress request is completed
+        # and that's all we need.
+        @lock.synchronize_exclusive do
+        end
+      end
+
+      system "notify-send -t 1000 'killing child'"
+      ChildController.kill_child!(true)
+
+      p_log :child, "old worker is dead"
+      check_dir!
+    end
+  end
+
+  def loop
+    check_dir!
+    lock = @lock
+
+    while true
+      socket = @server.accept
+      p_log :upstream, "got new connection: #{socket.fileno}"
+      set_cloexec(socket)
+
+      begin
+        check_dir!
+      rescue Exception
+        p_log :critical, "Dropping connection due to exception from check_dir!:\n#{$!.diagnose}"
+        socket.close rescue nil
+        next
+      end
+
+      Thread.run_diag do
+        p_log :upstream, "spawned new thread"
+        lock.synchronize_shared do
+          downstream_socket = Reloader.socket_factory.call
+          set_cloexec(downstream_socket)
+          downstream = DownstreamConnection.new(downstream_socket, socket)
+          UpstreamConnection.new(socket, downstream).run
+        end
+      end
+    end
+  end
+end
+
+$server_port = 8080
+$custom_patterns = false
+
+opts = OptionParser.new
+opts.banner = "Usage: #{File.basename($0)} [options] command..."
+opts.on("-u", "--upstream-port=VAL", Integer, "Port to listen on") {|x| $server_port = x}
+opts.on("-d", "--downstream-port=VAL", Integer, "Port where app server listens") {|x| $child_port = x}
+opts.on("-T", "--spawn-timeout=VAL", Float, "Timeout for app server port readiness") {|x| $child_spawn_timeout = x}
+opts.on("-s", "--kill-signal=VAL", "Signal used to kill child") {|x| $kill_signal = x}
+opts.on("-g", "--kill-gently", "Wait requests completion before killing/respawning") { $gentle_killer = true }
+opts.on("-w", "--watch=VAL", "File pattern to watch (add as many as you want)") do |x|
+  unless $custom_patterns
+    $custom_patterns = true
+    $interesting_files_patterns = []
+  end
+  $interesting_files_patterns << x
+end
+new_argv = opts.parse(*ARGV)
+ARGV.replace(new_argv)
+
+if ARGV.empty?
+  puts "Need command to spawn child"
+  exit 1
+end
+
+p_log :opts, "child_port: ", $child_port
+p_log :opts, "server_port: ", $server_port
+p_log :opts, "interesting_files_patterns: ", $interesting_files_patterns
+
+Reloader.new($server_port).loop

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: webdevreloader
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  version: "0.5"
+platform: ruby
+authors: 
+- Aliaksey Kandratsenka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-06 00:00:00 -07:00
+default_executable: reloader
+dependencies: []
+
+description: reloader watches your application files and reloads your app when something changes
+email: alk@tut.by
+executables: 
+- reloader
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/reloader
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Smart web application reloader
+test_files: []
+