multibinder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04308acfb4e6a38f2ec0d7bd53b3bf921328ece0
+  data.tar.gz: cd6936ec293af4d11edf3d13e6e26a402c6dcb9e
+SHA512:
+  metadata.gz: 071505702ac618577faf5de290e3b87c6b0f52d4579fa08d259b501509d1b47a2b5e040eedabc32438e3e2b5bbe77cbbcc577269dba62b8d7fc69fb2eeac1e46
+  data.tar.gz: 7fbf21103b70a01ad7e87768774f6fd37eef0980f4375db09e3bb6996685969068b6b57ce1711b6962040e54177437077bec8226a8bba2d9cb5dcccfd0ec949b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in binder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Theo Julienne
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+### multibinder
+
+multibinder is a tiny ruby server that makes writing zero-downtime-reload services simpler. It accepts connections on a UNIX domain socket and binds an arbitrary number of LISTEN sockets given their ip+port combinations. When a bind is requested, the LISTEN socket is sent over the UNIX domain socket using ancillary data. Subsequent identical binds receive the same LISTEN socket.
+
+multibinder runs on its own, separate from the daemons that use the sockets. multibinder can be re-exec itself to take upgrades by sending it a `SIGUSR1` - existing binds will be retained across re-execs.
+
+#### Server usage
+
+After installing multibinder, you can run the multibinder daemon:
+
+```
+bundle exec multibinder /path/to/control.sock
+```
+
+#### Client usage
+
+The multibinder library retrieves a socket from a local multibinder server, communicating over the socket you specify in the `MULTIBINDER_SOCK` environment variable (which has to be the same as specified when running multibinder, and the user must have permission to access the file).
+
+```ruby
+require 'multibinder'
+
+server = MultiBinder.bind '127.0.0.1', 8000
+
+# use the server socket
+# ... server.accept ...
+```
+
+The socket has close-on-exec disabled and is ready to be used in Ruby or passed on to a real service like haproxy via spawn/exec. For an example of using multibinder with haproxy (there are a couple of tricks), see [the haproxy test shim](https://github.com/theojulienne/multibinder/blob/master/test/haproxy_shim.rb).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/multibinder

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'json'
+
+class MultiBinderServer
+  def initialize(control_file)
+    @control_file = control_file
+  end
+
+  def handle_client(s)
+    loop do
+      msg, _, _, _ = s.recvmsg
+      break if msg.empty?
+      request = JSON.parse(msg)
+      puts "Request: #{request}"
+
+      case request['method']
+      when 'bind'
+        do_bind s, request
+      else
+        response = { :error => { :code => -32601, :message => 'Method not found' } }
+        s.sendmsg JSON.dump(response), 0, nil
+      end
+    end
+  end
+
+  def bind_to_env(bind)
+    "MULTIBINDER_BIND__tcp__#{bind['address'].sub('.','_')}__#{bind['port']}"
+  end
+
+  def do_bind(s, request)
+    bind = request['params'][0]
+
+    begin
+      name = bind_to_env(bind)
+      if ENV[name]
+        socket = IO.for_fd ENV[name].to_i
+      else
+        socket = Socket.new(:INET, :STREAM, 0)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        socket.fcntl(Fcntl::F_SETFD, socket.fcntl(Fcntl::F_GETFD) & (-Fcntl::FD_CLOEXEC-1))
+        socket.bind(Addrinfo.tcp(bind['address'], bind['port']))
+        socket.listen(bind['backlog'] || 1000)
+        ENV[name] = socket.fileno.to_s
+      end
+    rescue Exception => e
+      response = {
+        :jsonrpc => '2.0',
+        :id => request['id'],
+        :error => {
+          :code => 10000,
+          :message => "Could not bind: #{e.message}",
+          :backtrace => e.backtrace,
+        },
+      }
+      s.sendmsg JSON.dump(response), 0, nil
+      return
+    else
+      response = {
+        :jsonrpc => '2.0',
+        :id => request['id'],
+        :result => true,
+      }
+      s.sendmsg JSON.dump(response), 0, nil, Socket::AncillaryData.unix_rights(socket)
+    end
+  end
+
+  def bind_accept_loop
+    UNIXServer.open(@control_file) do |serv|
+      puts "Listening for binds on control socket: #{@control_file}"
+      STDOUT.flush
+
+      Signal.trap("USR1") do
+        serv.close
+        begin
+          File.unlink @control_file
+        rescue Errno::ENOENT
+          # cool!
+        end
+
+        # respawn ourselved in an identical way, keeping state through environment.
+        puts 'Respawning...'
+        STDOUT.flush
+        args = [RbConfig.ruby, $0, *ARGV]
+        args << { :close_others => false } if RUBY_VERSION > '1.9' # RUBBY.
+        Kernel.exec *args
+      end
+
+      loop do
+        s = serv.accept
+        begin
+          handle_client s
+        rescue Exception => e
+          puts e
+          puts e.backtrace
+        ensure
+          s.close
+        end
+      end
+    end
+  end
+
+  def serve
+    begin
+      File.unlink @control_file
+      puts "Removed existing control socket: #{@control_file}"
+    rescue Errno::ENOENT
+      # :+1:
+    end
+
+    begin
+      bind_accept_loop
+    ensure
+      begin
+        File.unlink @control_file
+      rescue Errno::ENOENT
+        # cool!
+      end
+    end
+  end
+end
+
+if ARGV.length == 0
+  abort "Usage: #{$0} <path/to/control.sock>"
+else
+  server = MultiBinderServer.new ARGV[0]
+  server.serve
+end

data/lib/multibinder.rb

@@ -0,0 +1,33 @@
+require 'multibinder/version'
+require 'json'
+
+module MultiBinder
+  def self.bind(address, port)
+    abort 'MULTIBINDER_SOCK environment variable must be set' if !ENV['MULTIBINDER_SOCK']
+
+    binder = UNIXSocket.open(ENV['MULTIBINDER_SOCK'])
+
+    # make the request
+    binder.sendmsg JSON.dump({
+      :jsonrpc => '2.0',
+      :method => 'bind',
+      :params => [{
+        :address => address,
+        :port => port,
+      }]
+    }, 0, nil)
+
+    # get the response
+    msg, _, _, ctl = binder.recvmsg(:scm_rights=>true)
+    response = JSON.parse(msg)
+    if response['error']
+      raise response['error']['message']
+    end
+
+    binder.close
+
+    socket = ctl.unix_rights[0]
+    socket.fcntl(Fcntl::F_SETFD, socket.fcntl(Fcntl::F_GETFD) & (-Fcntl::FD_CLOEXEC-1))
+    socket
+  end
+end

data/lib/multibinder/version.rb

@@ -0,0 +1,3 @@
+module MultiBinder
+  VERSION = "0.0.1"
+end

data/multibinder.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multibinder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "multibinder"
+  spec.version       = MultiBinder::VERSION
+  spec.authors       = ["Theo Julienne"]
+  spec.email         = ["theojulienne@github.com"]
+  spec.summary       = %q{multibinder is a tiny ruby server that makes writing zero-downtime-reload services simpler.}
+  spec.homepage      = "https://github.com/theojulienne/multibinder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/script/cibuild

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+export RUBY_VERSION=2.1.6-github
+export RBENV_VERSION=2.1.6-github
+export PATH=/usr/share/rbenv/shims:/usr/sbin:$PATH
+export BASE_DIR=/data/binder
+
+#bundle install --local --quiet --path vendor/gems
+
+REALPATH=$(cd $(dirname "$0") && pwd)
+
+cd $REALPATH/../
+script/test

data/script/test

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+SHELL=/bin/sh
+
+date "+%Y-%m-%dT%H:%M:%SZ"
+echo "Beginning tests for multibinder"
+echo "==="
+
+ls -1 test/test-*.sh | xargs -I % -n 1 ${SHELL} % --batch
+
+echo "==="
+date "+%Y-%m-%dT%H:%M:%SZ"
+echo "Done."

data/test/haproxy_shim.rb

@@ -0,0 +1,27 @@
+require 'multibinder'
+
+server = MultiBinder.bind '127.0.0.1', ARGV[0].to_i
+
+cfg_fn = "#{ENV['TEMPDIR']}/haproxy.cfg"
+
+File.write(cfg_fn, <<eos)
+global
+  maxconn 256
+
+defaults
+  mode http
+  timeout connect 5000ms
+  timeout client 50000ms
+  timeout server 50000ms
+
+frontend http-in
+  bind fd@#{server.fileno}
+  http-request deny
+eos
+
+pid = Process.spawn "haproxy", "-f", cfg_fn, :close_others => false
+
+Signal.trap("INT") { Process.kill "USR1", pid }
+Signal.trap("TERM") { Process.kill "USR1", pid }
+
+Process.waitpid

data/test/httpbinder.rb

@@ -0,0 +1,21 @@
+require 'socket'
+require 'json'
+require 'multibinder'
+
+server = MultiBinder.bind '127.0.0.1', ARGV[0].to_i
+
+loop do
+  socket, _ = server.accept
+  request = socket.gets
+  puts request
+
+  socket.print "HTTP/1.0 200 OK\r\n"
+  socket.print "Content-Type: text/plain\r\n"
+  socket.print "Connection: close\r\n"
+
+  socket.print "\r\n"
+
+  socket.print "Hello World #{ARGV[1] || ''}!\n"
+
+  socket.close
+end

data/test/lib-project.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+# Extends lib.sh for this project
+
+project_setup () {
+  local control_sock=${TEMPDIR}/multibinder.sock
+  launch_service "multibinder" bundle exec multibinder ${control_sock}
+
+  tries=0
+  while [ ! -S $control_sock ]; do
+    sleep .1
+    echo 'Waiting for control socket...'
+    tries=$((tries + 1))
+    if [ $tries -gt 10 ]; then
+      echo 'Giving up.'
+      exit 1
+    fi
+  done
+}
+
+project_cleanup () {
+  kill_service "multibinder"
+}

data/test/lib.sh

@@ -0,0 +1,282 @@
+#!/bin/sh
+# Usage: . lib.sh
+# Simple shell command language test library.
+#
+# Tests must follow the basic form:
+#
+#   begin_test "the thing"
+#   (
+#        set -e
+#        echo "hello"
+#        false
+#   )
+#   end_test
+#
+# When a test fails its stdout and stderr are shown.
+#
+# Note that tests must `set -e' within the subshell block or failed assertions
+# will not cause the test to fail and the result may be misreported.
+#
+# Copyright (c) 2011-13 by Ryan Tomayko <http://tomayko.com>
+# License: MIT
+
+set -e
+
+TEST_DIR=$(dirname "$0")
+ROLE=$(basename $(dirname "$0"))
+BASE_DIR=$(cd $(dirname "$0")/../ && pwd)
+
+TEMPDIR=$(mktemp -d /tmp/test-XXXXXX)
+HOME=$TEMPDIR; export HOME
+TRASHDIR="${TEMPDIR}"
+LOGDIR="$TEMPDIR/log"
+
+BUILD_DIR=${TEMPDIR}/build
+ROLE_DIR=$BUILD_DIR
+
+# keep track of num tests and failures
+tests=0
+failures=0
+
+#mkdir -p $TRASHDIR
+mkdir -p $LOGDIR
+
+# offset port numbers if running in '--batch' mode
+TEST_PORT_OFFSET=0
+if [ "$1" = "--batch" ]; then
+  TEST_PORT_OFFSET=$(ls -1 $(dirname "$0")/test-*.sh | grep -n $(basename "$0") | grep -o "^[0-9]*")
+  TEST_PORT_OFFSET=$(( $TEST_PORT_OFFSET - 1 ))
+fi
+
+# Sanity check up front that nothing is currently using the ports we're
+# trying use; port collisions will cause non-obvious test failures.
+tests_use_port () {
+  local p=$(offset_port $1)
+
+  set +e
+  lsof -n -iTCP:$p | grep -q LISTEN
+  if [ $? -eq 0 ]; then
+    echo "**** $(basename "$0") FAIL: Found something using port $p, bailing."
+    lsof -n -iTCP:$p | grep -e ":$p" | sed -e "s/^/lsof failure $(basename "$0"): /"
+    exit 1
+  fi
+  set -e
+}
+
+# Given a port, increment it by our test number so multiple tests can run
+# in parallel without conflicting.
+offset_port () {
+  local base_port="$1"
+
+  echo $(( $base_port + $TEST_PORT_OFFSET ))
+}
+
+# Mark the beginning of a test. A subshell should immediately follow this
+# statement.
+begin_test () {
+    test_status=$?
+    [ -n "$test_description" ] && end_test $test_status
+    unset test_status
+
+    tests=$(( tests + 1 ))
+    test_description="$1"
+
+    exec 3>&1 4>&2
+    out="$TRASHDIR/out"
+    err="$TRASHDIR/err"
+    exec 1>"$out" 2>"$err"
+
+    echo "begin_test: $test_description"
+
+    # allow the subshell to exit non-zero without exiting this process
+    set -x +e
+    before_time=$(date '+%s')
+}
+
+report_failure () {
+  msg=$1
+  desc=$2
+  failures=$(( failures + 1 ))
+  printf "test: %-60s $msg\n" "$desc ..."
+  (
+    echo "-- stdout --"
+    sed 's/^/    /' <"$TRASHDIR/out"
+    echo "-- stderr --"
+    grep -a -v -e '^\+ end_test' -e '^+ set +x' <"$TRASHDIR/err" |
+      sed 's/^/    /'
+
+    for service_log in $(ls $LOGDIR/*.log); do
+      echo "-- $(basename "$service_log") --"
+      sed 's/^/    /' <"$service_log"
+    done
+
+    echo "-- end --"
+  ) 1>&2
+}
+
+# Mark the end of a test.
+end_test () {
+    test_status="${1:-$?}"
+    ex_fail="${2:-0}"
+    after_time=$(date '+%s')
+    set +x -e
+    exec 1>&3 2>&4
+    elapsed_time=$((after_time - before_time))
+
+    if [ "$test_status" -eq 0 ]; then
+      if [ "$ex_fail" -eq 0 ]; then
+        printf "test: %-60s OK (${elapsed_time}s)\n" "$test_description ..."
+      else
+        report_failure "OK (unexpected)" "$test_description ..."
+      fi
+    else
+      if [ "$ex_fail" -eq 0 ]; then
+        report_failure "FAILED (${elapsed_time}s)" "$test_description ..."
+      else
+        printf "test: %-60s FAILED (expected)\n" "$test_description ..."
+      fi
+    fi
+    unset test_description
+}
+
+# Mark the end of a test that is expected to fail.
+end_test_exfail () {
+  end_test $? 1
+}
+
+atexit () {
+    [ -z "$KEEPTRASH" ] && rm -rf "$TEMPDIR"
+    if [ $failures -gt 0 ]; then
+        exit 1
+    else
+        exit 0
+    fi
+}
+trap "atexit" EXIT
+
+cleanup() {
+    set +e
+
+    project_cleanup "$@"
+
+    for pid_file in $(ls ${TEMPDIR}/*.pid); do
+      echo "Cleaning up process in $pid_file ..."
+      kill $(cat ${pid_file}) || true
+    done
+
+    echo "Cleaning up any remaining pid files."
+    rm -rf ${TEMPDIR}/*.pid
+
+    if [ -f "$TEMPDIR/core" ]; then
+      echo "found a coredump, failing"
+      exit 1
+    fi
+}
+
+setup() {
+  trap cleanup EXIT
+  trap cleanup INT
+  trap cleanup TERM
+
+  project_setup "$@"
+
+  set -e
+}
+
+wait_for_file () {
+  (
+    SERVICE="$1"
+    PID_FILE="$2"
+
+    set +e
+
+    tries=0
+
+    echo "Waiting for $SERVICE to drop $PID_FILE"
+    while [ ! -e "$PID_FILE" ]; do
+      tries=$(( $tries + 1 ))
+      if [ $tries -gt 50 ]; then
+        echo "FAILED: $SERVICE did not drop $PID_FILE after $tries attempts"
+        exit 1
+      fi
+      echo "Waiting for $SERVICE to drop $PID_FILE"
+      sleep 0.1
+    done
+    echo "OK -- $SERVICE dropped $PID_FILE"
+    exit 0
+  )
+}
+
+# wait for a process to start accepting connections
+wait_for_port () {
+  (
+    SERVICE="$1"
+    SERVICE_PORT="$2"
+
+    set +e
+
+    tries=0
+
+    echo "Waiting for $SERVICE to start accepting connections"
+    if [ $(uname) = "Linux" ]; then
+      echo "PROXY TCP4 127.0.0.1 127.0.0.1 123 123\r" | nc -q 0 localhost $SERVICE_PORT 2>&1 >/dev/null
+    else
+      echo "PROXY TCP4 127.0.0.1 127.0.0.1 123 123\r" | nc localhost $SERVICE_PORT 2>&1 >/dev/null
+    fi
+    while [ $? -ne 0 ]; do
+      tries=$(( $tries + 1 ))
+      if [ $tries -gt 50 ]; then
+        echo "FAILED: $SERVICE not accepting connections after $tries attempts"
+        exit 1
+      fi
+      echo "Waiting for $SERVICE to start accepting connections"
+      sleep 0.1
+      if [ $(uname) = "Linux" ]; then
+        echo "PROXY TCP4 127.0.0.1 127.0.0.1 123 123\r" | nc -q 0 localhost $SERVICE_PORT 2>&1 >/dev/null
+      else
+        echo "PROXY TCP4 127.0.0.1 127.0.0.1 123 123\r" | nc localhost $SERVICE_PORT 2>&1 >/dev/null
+      fi
+    done
+    echo "OK -- $SERVICE seems to be accepting connections"
+    exit 0
+  )
+}
+
+# Allow simple launching of a background service, keeping track of the pid
+launch_service () {
+  local service_name=$1
+  shift
+
+  "$@" >${LOGDIR}/${service_name}.log 2>&1 &
+  echo "$!" > ${TEMPDIR}/${service_name}.pid
+}
+
+# Clean up after a service launched with launch_service
+kill_service () {
+  local service_name=$1
+  kill $(cat ${TEMPDIR}/${service_name}.pid) || true
+  rm -rf ${TEMPDIR}/${service_name}.pid
+}
+
+service_pid () {
+  local service_name=$1
+  cat ${TEMPDIR}/${service_name}.pid
+}
+
+service_log () {
+  local service_name=$1
+  echo ${LOGDIR}/${service_name}.log
+}
+
+# Stub out functions and let the project extend them
+project_setup () {
+  true
+}
+
+project_cleanup () {
+  true
+}
+
+if [ -e "$BASE_DIR/test/lib-project.sh" ]; then
+  . $BASE_DIR/test/lib-project.sh
+fi

data/test/test-haproxy.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+#
+# test-haproxy.sh: check that we can work with haproxy (if it's installed)
+
+REALPATH=$(cd $(dirname "$0") && pwd)
+. "${REALPATH}/lib.sh"
+
+TEST_PORT=8000
+
+tests_use_port $TEST_PORT
+
+if ! which -s haproxy; then
+  echo "haproxy not available, skipping tests."
+  exit 0
+fi
+
+begin_test "haproxy runs with multibinder"
+(
+  setup
+
+  export TEMPDIR
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "haproxy" bundle exec ruby test/haproxy_shim.rb $(offset_port $TEST_PORT)
+
+  wait_for_port "haproxy" $(offset_port $TEST_PORT)
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/ | grep -q 'Request forbidden'
+)
+end_test

data/test/test-simple.sh

@@ -0,0 +1,99 @@
+#!/bin/sh
+#
+# test-simple.sh: simple sanity checks
+
+REALPATH=$(cd $(dirname "$0") && pwd)
+. "${REALPATH}/lib.sh"
+
+TEST_PORT=8000
+
+tests_use_port $TEST_PORT
+
+begin_test "server binds and accepts through multibinder"
+(
+  setup
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT)
+
+  wait_for_port "binder" $(offset_port $TEST_PORT)
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/ | grep -q 'Hello World'
+)
+end_test
+
+begin_test "server can restart without requests failing while down"
+(
+  setup
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT)
+
+  wait_for_port "binder" $(offset_port $TEST_PORT)
+
+  kill_service "http"
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/ | grep -q 'Hello World' &
+  curl_pid=$!
+
+  sleep 0.5
+
+  # now restart the service
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT)
+
+  # curl should finish, and succeed
+  wait $curl_pid
+)
+end_test
+
+
+begin_test "server can load a second copy then terminate the first"
+(
+  setup
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT) "first"
+  wait_for_port "binder" $(offset_port $TEST_PORT)
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/r1 | grep -q 'Hello World first'
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http2" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT) "second"
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/r2 | egrep -q 'Hello World (first|second)'
+
+  kill_service "http"
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/r3 | grep -q 'Hello World second'
+
+  kill_service "http2"
+)
+end_test
+
+begin_test "multibinder restarts safely on sigusr1"
+(
+  setup
+
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT)
+  wait_for_port "binder" $(offset_port $TEST_PORT)
+
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/r1 | grep -q 'Hello World'
+
+  kill_service "http"
+
+  lsof -p $(service_pid "multibinder")
+
+  kill -USR1 $(service_pid "multibinder")
+
+  # should still be running, should still be listening
+  lsof -p $(service_pid "multibinder")
+  lsof -i :$(offset_port $TEST_PORT) -a -p $(service_pid "multibinder")
+
+  # should be able to request the bind again
+  MULTIBINDER_SOCK=${TEMPDIR}/multibinder.sock launch_service "http" bundle exec ruby test/httpbinder.rb $(offset_port $TEST_PORT)
+  wait_for_port "multibinder" $(offset_port $TEST_PORT)
+
+  # requests should work
+  curl --max-time 5 http://localhost:$(offset_port $TEST_PORT)/r2 | grep -q 'Hello World'
+
+  # and multibinder should have started listening on the control socket twice
+  grep 'Respawning' $(service_log "multibinder")
+  grep 'Listening for binds' $(service_log "multibinder") | grep -n 'Listen' | grep "2:"
+)
+end_test

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: multibinder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Theo Julienne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- theojulienne@github.com
+executables:
+- multibinder
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/multibinder
+- lib/multibinder.rb
+- lib/multibinder/version.rb
+- multibinder.gemspec
+- script/cibuild
+- script/test
+- test/haproxy_shim.rb
+- test/httpbinder.rb
+- test/lib-project.sh
+- test/lib.sh
+- test/test-haproxy.sh
+- test/test-simple.sh
+homepage: https://github.com/theojulienne/multibinder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.3
+signing_key: 
+specification_version: 4
+summary: multibinder is a tiny ruby server that makes writing zero-downtime-reload
+  services simpler.
+test_files:
+- test/haproxy_shim.rb
+- test/httpbinder.rb
+- test/lib-project.sh
+- test/lib.sh
+- test/test-haproxy.sh
+- test/test-simple.sh
+has_rdoc: