puma-simon 3.7.1

data/Rakefile

@@ -0,0 +1,158 @@
+require "bundler/setup"
+require "hoe"
+require "rake/extensiontask"
+require "rake/javaextensiontask"
+
+IS_JRUBY = defined?(RUBY_ENGINE) ? RUBY_ENGINE == "jruby" : false
+
+Hoe.plugin :git
+Hoe.plugin :ignore
+
+HOE = Hoe.spec "puma" do
+  self.readme_file    = "README.md"
+  self.urls = %w!http://puma.io https://github.com/puma/puma!
+
+  license "BSD-3-Clause"
+  developer 'Evan Phoenix', 'evan@phx.io'
+
+  spec_extras[:extensions]  = ["ext/puma_http11/extconf.rb"]
+  spec_extras[:executables] = ['puma', 'pumactl']
+  spec_extras[:homepage] = self.urls.first
+
+  require_ruby_version ">= 1.9.3"
+
+  dependency "rack", [">= 1.1", "< 3.0"], :development
+
+  extra_dev_deps << ["rake-compiler", "~> 0.8"]
+end
+
+task :prerelease => [:clobber, :check_manifest, :test]
+
+# hoe/test and rake-compiler don't seem to play well together, so disable
+# hoe/test's .gemtest touch file thingy for now
+HOE.spec.files -= [".gemtest"]
+
+include Hoe::Git
+
+desc "Print the current changelog."
+task "changelog" do
+  tag   = ENV["FROM"] || git_tags.last
+  range = [tag, "HEAD"].compact.join ".."
+  cmd   = "git log #{range} '--format=tformat:%B|||%aN|||%aE|||'"
+  now   = Time.new.strftime "%Y-%m-%d"
+
+  changes = `#{cmd}`.split(/\|\|\|/).each_slice(3).map { |msg, author, email|
+              msg.split(/\n/).reject { |s| s.empty? }.first
+            }.flatten.compact
+
+  $changes = Hash.new { |h,k| h[k] = [] }
+
+  codes = {
+    "!" => :major,
+    "+" => :minor,
+    "*" => :minor,
+    "-" => :bug,
+    "?" => :unknown,
+  }
+
+  codes_re = Regexp.escape codes.keys.join
+
+  changes.each do |change|
+    if change =~ /^\s*([#{codes_re}])\s*(.*)/ then
+      code, line = codes[$1], $2
+    else
+      code, line = codes["?"], change.chomp
+    end
+
+    $changes[code] << line
+  end
+
+  puts "## #{ENV['VERSION'] || 'NEXT'} / #{now}"
+  puts
+  changelog_section :major
+  changelog_section :minor
+  changelog_section :bug
+  changelog_section :unknown
+  puts
+end
+
+# generate extension code using Ragel (C and Java)
+desc "Generate extension code (C and Java) using Ragel"
+task :ragel
+
+file 'ext/puma_http11/http11_parser.c' => ['ext/puma_http11/http11_parser.rl'] do |t|
+  begin
+    sh "ragel #{t.prerequisites.last} -C -G2 -I ext/puma_http11 -o #{t.name}"
+  rescue
+    fail "Could not build wrapper using Ragel (it failed or not installed?)"
+  end
+end
+task :ragel => ['ext/puma_http11/http11_parser.c']
+
+file 'ext/puma_http11/org/jruby/puma/Http11Parser.java' => ['ext/puma_http11/http11_parser.java.rl'] do |t|
+  begin
+    sh "ragel #{t.prerequisites.last} -J -G2 -I ext/puma_http11 -o #{t.name}"
+  rescue
+    fail "Could not build wrapper using Ragel (it failed or not installed?)"
+  end
+end
+task :ragel => ['ext/puma_http11/org/jruby/puma/Http11Parser.java']
+
+if !IS_JRUBY
+
+# compile extensions using rake-compiler
+# C (MRI, Rubinius)
+Rake::ExtensionTask.new("puma_http11", HOE.spec) do |ext|
+  # place extension inside namespace
+  ext.lib_dir = "lib/puma"
+
+  ext.cross_compile = true
+  ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32']
+  ext.cross_compiling do |spec|
+    # add fat-binary stub only when cross compiling
+    spec.files << "lib/puma/puma_http11.rb"
+  end
+
+  CLEAN.include "lib/puma/{1.8,1.9}"
+  CLEAN.include "lib/puma/puma_http11.rb"
+end
+
+else
+
+# Java (JRuby)
+Rake::JavaExtensionTask.new("puma_http11", HOE.spec) do |ext|
+  ext.lib_dir = "lib/puma"
+end
+
+end
+
+# the following is a fat-binary stub that will be used when
+# require 'puma/puma_http11' and will use either 1.8 or 1.9 version depending
+# on RUBY_VERSION
+file "lib/puma/puma_http11.rb" do |t|
+  File.open(t.name, "w") do |f|
+    f.puts "RUBY_VERSION =~ /(\d+.\d+)/"
+    f.puts 'require "puma/#{$1}/puma_http11"'
+  end
+end
+
+# tests require extension be compiled, but depend on the platform
+if IS_JRUBY
+  task :test => [:java]
+else
+  task :test => [:compile]
+end
+
+namespace :test do
+  desc "Run the integration tests"
+  task :integration do
+    sh "cd test/shell; sh run.sh"
+  end
+
+  desc "Run all tests"
+  if defined?(JRUBY_VERSION) and ENV['TRAVIS']
+    task :all => :test
+  else
+    task :all => [:test, "test:integration"]
+  end
+end

data/Release.md

@@ -0,0 +1,9 @@
+# Release process
+
+Using "3.7.1" as a version string example.
+
+1. `be rake release_sanity VERSION=3.7.1`
+2. `be rake release VERSION=3.7.1`
+3. Switch to latest JRuby version
+4. `rake java gem`
+5. `gem push pkg/puma-3.7.1-java.gem`

data/bin/puma

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2011 Evan Phoenix
+#
+
+require 'puma/cli'
+
+cli = Puma::CLI.new ARGV
+
+cli.run

data/bin/puma-wild

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2014 Evan Phoenix
+#
+
+require 'rubygems'
+
+gems = ARGV.shift
+
+inc = ""
+
+if gems == "-I"
+  inc = ARGV.shift
+  $LOAD_PATH.concat inc.split(":")
+  gems = ARGV.shift
+end
+
+gems.split(",").each do |s|
+  name, ver = s.split(":",2)
+  gem name, ver
+end
+
+module Puma; end
+
+Puma.const_set("WILD_ARGS", ["-I", inc, gems])
+
+require 'puma/cli'
+
+cli = Puma::CLI.new ARGV
+
+cli.run

data/bin/pumactl

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'puma/control_cli'
+
+cli = Puma::ControlCLI.new ARGV.dup
+
+begin
+  cli.run
+rescue => e
+  STDERR.puts e.message
+  exit 1
+end

data/docs/nginx.md

@@ -0,0 +1,80 @@
+# Nginx configuration example file
+
+This is a very common setup using an upstream. It was adapted from some Capistrano recipe I found on the Internet a while ago.
+
+```
+upstream myapp {
+  server unix:///myapp/tmp/puma.sock;
+}
+
+server {
+  listen 80;
+  server_name myapp.com;
+
+  # ~2 seconds is often enough for most folks to parse HTML/CSS and
+  # retrieve needed images/icons/frames, connections are cheap in
+  # nginx so increasing this is generally safe...
+  keepalive_timeout 5;
+
+  # path for static files
+  root /myapp/public;
+  access_log /myapp/log/nginx.access.log;
+  error_log /myapp/log/nginx.error.log info;
+
+  # this rewrites all the requests to the maintenance.html
+  # page if it exists in the doc root. This is for capistrano's
+  # disable web task
+  if (-f $document_root/maintenance.html) {
+    rewrite  ^(.*)$  /maintenance.html last;
+    break;
+  }
+
+  location / {
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header Host $http_host;
+
+    # If the file exists as a static file serve it directly without
+    # running all the other rewrite tests on it
+    if (-f $request_filename) {
+      break;
+    }
+
+    # check for index.html for directory index
+    # if it's there on the filesystem then rewrite
+    # the url to add /index.html to the end of it
+    # and then break to send it to the next config rules.
+    if (-f $request_filename/index.html) {
+      rewrite (.*) $1/index.html break;
+    }
+
+    # this is the meat of the rack page caching config
+    # it adds .html to the end of the url and then checks
+    # the filesystem for that file. If it exists, then we
+    # rewrite the url to have explicit .html on the end
+    # and then send it on its way to the next config rule.
+    # if there is no file on the fs then it sets all the
+    # necessary headers and proxies to our upstream pumas
+    if (-f $request_filename.html) {
+      rewrite (.*) $1.html break;
+    }
+
+    if (!-f $request_filename) {
+      proxy_pass http://myapp;
+      break;
+    }
+  }
+
+  # Now this supposedly should work as it gets the filenames with querystrings that Rails provides.
+  # BUT there's a chance it could break the ajax calls.
+  location ~* \.(ico|css|gif|jpe?g|png|js)(\?[0-9]+)?$ {
+     expires max;
+     break;
+  }
+
+  # Error pages
+  # error_page 500 502 503 504 /500.html;
+  location = /500.html {
+    root /myapp/current/public;
+  }
+}
+```

data/docs/signals.md

@@ -0,0 +1,43 @@
+The [unix signal](http://en.wikipedia.org/wiki/Unix_signal) is a method of sending messages between [processes](http://en.wikipedia.org/wiki/Process_(computing)). When a signal is sent, the operating system interrupts the target process's normal flow of execution. There are standard signals that are used to stop a process but there are also custom signals that can be used for other purposes. This document is an attempt to list all supported signals that Puma will respond to. In general, signals need only be sent to the master process of a cluster.
+
+## Sending Signals
+
+If you are new to signals it can be useful to see how they can be used. When a process is created in a *nix like operating system it will have a [PID - or process identifier](http://en.wikipedia.org/wiki/Process_identifier) that can be used to send signals to the process. For demonstration we will create an infinitely running process by tailing a file:
+
+```sh
+$ echo "foo" >> my.log
+$ irb
+> pid = Process.spawn 'tail -f my.log'
+```
+
+From here we can see that the tail process is running by using the `ps` command:
+
+```sh
+$ ps aux | grep tail
+schneems        87152   0.0  0.0  2432772    492 s032  S+   12:46PM   0:00.00 tail -f my.log
+```
+
+You can send a signal in Ruby using the [Process module](http://www.ruby-doc.org/core-2.1.1/Process.html#kill-method):
+
+```
+$ irb
+> puts pid
+=> 87152
+Process.detach(pid) # http://ruby-doc.org/core-2.1.1/Process.html#method-c-detach
+Process.kill("TERM", pid)
+```
+
+Now you will see via `ps` that there is no more `tail` process. Sometimes when referring to signals the `SIG` prefix will be used for instance `SIGTERM` is equivalent to sending `TERM` via `Process.kill`.
+
+## Puma Signals
+
+Puma cluster responds to these signals:
+
+- `TTIN` increment the worker count by 1
+- `TTOU` decrement the worker count by 1
+- `TERM` send `TERM` to worker. Worker will attempt to finish then exit.
+- `USR2` restart workers
+- `USR1` restart workers in phases, a rolling restart.
+- `HUP`  reopen log files defined in stdout_redirect configuration parameter
+- `INT` equivalent of sending Ctrl-C to cluster. Will attempt to finish then exit.
+- `CHLD`

data/docs/systemd.md

@@ -0,0 +1,197 @@
+# systemd
+
+[systemd](https://www.freedesktop.org/wiki/Software/systemd/) is a
+commonly available init system (PID 1) on many Linux distributions. It
+offers process monitoring (including automatic restarts) and other
+useful features for running Puma in production. Below is a sample
+puma.service configuration file for systemd:
+
+~~~~
+[Unit]
+Description=Puma HTTP Server
+After=network.target
+
+# Uncomment for socket activation (see below)
+# Requires=puma.socket
+
+[Service]
+# Foreground process (do not use --daemon in ExecStart or config.rb)
+Type=simple
+
+# Preferably configure a non-privileged user
+# User=
+
+# Specify the path to your puma application root
+# WorkingDirectory=
+
+# Helpful for debugging socket activation, etc.
+# Environment=PUMA_DEBUG=1
+
+# The command to start Puma
+# Here we are using a binstub generated via:
+# `bundle binstubs puma --path ./sbin`
+# in the WorkingDirectory (replace <WD> below)
+# You can alternatively use `bundle exec --keep-file-descriptors puma`
+# ExecStart=<WD>/sbin/puma -b tcp://0.0.0.0:9292 -b ssl://0.0.0.0:9293?key=key.pem&cert=cert.pem
+
+# Alternatively with a config file (in WorkingDirectory) and
+# comparable `bind` directives
+# ExecStart=<WD>/sbin/puma -C config.rb
+
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+~~~~
+
+See [systemd.exec](https://www.freedesktop.org/software/systemd/man/systemd.exec.html)
+for additional details.
+
+## Socket Activation
+
+systemd and puma also support socket activation, where systemd opens
+the listening socket(s) in advance and provides them to the puma master
+process on startup. Among other advantages, this keeps listening
+sockets open across puma restarts and achieves graceful restarts. To
+use socket activation, configure one or more `ListenStream`
+sockets in a companion `*.socket` systemd config file. Here is a sample
+puma.socket, matching the ports used in the above puma.service:
+
+~~~~
+[Unit]
+Description=Puma HTTP Server Accept Sockets
+
+[Socket]
+ListenStream=0.0.0.0:9292
+ListenStream=0.0.0.0:9293
+
+# AF_UNIX domain socket
+# SocketUser, SocketGroup, etc. may be needed for Unix domain sockets
+# ListenStream=/run/puma.sock
+
+# Socket options matching Puma defaults
+NoDelay=true
+ReusePort=true
+Backlog=1024
+
+[Install]
+WantedBy=sockets.target
+~~~~
+
+See [systemd.socket](https://www.freedesktop.org/software/systemd/man/systemd.socket.html)
+for additional configuration details.
+
+Note that the above configurations will work with Puma in either
+single process or cluster mode.
+
+## Usage
+
+Without socket activation, use `systemctl` as root (e.g. via `sudo`) as
+with other system services:
+
+~~~~ sh
+# After installing or making changes to puma.service
+systemctl daemon-reload
+
+# Enable so it starts on boot
+systemctl enable puma.service
+
+# Initial start up.
+systemctl start puma.service
+
+# Check status
+systemctl status puma.service
+
+# A normal restart. Warning: listeners sockets will be closed
+# while a new puma process initializes.
+systemctl restart puma.service
+~~~~
+
+With socket activation, several but not all of these commands should
+be run for both socket and service:
+
+~~~~ sh
+# After installing or making changes to either puma.socket or
+# puma.service.
+systemctl daemon-reload
+
+# Enable both socket and service so they start on boot.  Alternatively
+# you could leave puma.service disabled and systemd will start it on
+# first use (with startup lag on first request)
+systemctl enable puma.socket puma.service
+
+# Initial start up. The Requires directive (see above) ensures the
+# socket is started before the service.
+systemctl start puma.socket puma.service
+
+# Check status of both socket and service.
+systemctl status puma.socket puma.service
+
+# A "hot" restart, with systemd keeping puma.socket listening and
+# providing to the new puma (master) instance.
+systemctl restart puma.service
+
+# A normal restart, needed to handle changes to
+# puma.socket, such as changing the ListenStream ports. Note
+# daemon-reload (above) should be run first.
+systemctl restart puma.socket puma.service
+~~~~
+
+Here is sample output from `systemctl status` with both service and
+socket running:
+
+~~~~
+● puma.socket - Puma HTTP Server Accept Sockets
+   Loaded: loaded (/etc/systemd/system/puma.socket; enabled; vendor preset: enabled)
+   Active: active (running) since Thu 2016-04-07 08:40:19 PDT; 1h 2min ago
+   Listen: 0.0.0.0:9233 (Stream)
+           0.0.0.0:9234 (Stream)
+
+Apr 07 08:40:19 hx systemd[874]: Listening on Puma HTTP Server Accept Sockets.
+
+● puma.service - Puma HTTP Server
+   Loaded: loaded (/etc/systemd/system/puma.service; enabled; vendor preset: enabled)
+   Active: active (running) since Thu 2016-04-07 08:40:19 PDT; 1h 2min ago
+ Main PID: 28320 (ruby)
+   CGroup: /system.slice/puma.service
+           ├─28320 puma 3.3.0 (tcp://0.0.0.0:9233,ssl://0.0.0.0:9234?key=key.pem&cert=cert.pem) [app]
+           ├─28323 puma: cluster worker 0: 28320 [app]
+           └─28327 puma: cluster worker 1: 28320 [app]
+
+Apr 07 08:40:19 hx puma[28320]: Puma starting in cluster mode...
+Apr 07 08:40:19 hx puma[28320]: * Version 3.3.0 (ruby 2.2.4-p230), codename: Jovial Platypus
+Apr 07 08:40:19 hx puma[28320]: * Min threads: 0, max threads: 16
+Apr 07 08:40:19 hx puma[28320]: * Environment: production
+Apr 07 08:40:19 hx puma[28320]: * Process workers: 2
+Apr 07 08:40:19 hx puma[28320]: * Phased restart available
+Apr 07 08:40:19 hx puma[28320]: * Activated tcp://0.0.0.0:9233
+Apr 07 08:40:19 hx puma[28320]: * Activated ssl://0.0.0.0:9234?key=key.pem&cert=cert.pem
+Apr 07 08:40:19 hx puma[28320]: Use Ctrl-C to stop
+~~~~
+
+## Alternative background process configuration
+
+If Capistrano and [capistrano3-puma](https://github.com/seuros/capistrano-puma) tasks are used you can use the following configuration. In this case, you would skip systemd Socket Activation, since Puma handles the socket by itself:
+
+~~~~
+[Service]
+# Background process configuration (use with --daemon in ExecStart)
+Type=forking
+
+# To learn which exact command is to be used to execute at "ExecStart" of this
+# Service, ask Capistrano: `cap <stage> puma:start --dry-run`. Your result
+# may differ from this example, for example if you use a Ruby version
+# manager. `<WD>` is short for "your working directory". Replace it with your
+# path.
+ExecStart=bundle exec puma -C <WD>/shared/puma.rb --daemon
+
+# To learn which exact command is to be used to execute at "ExecStop" of this
+# Service, ask Capistrano: `cap <stage> puma:stop --dry-run`. Your result
+# may differ from this example, for example if you use a Ruby version
+# manager. `<WD>` is short for "your working directory". Replace it with your
+# path.
+ExecStop=bundle exec pumactl -S <WD>/shared/tmp/pids/puma.state stop
+
+# PIDFile setting is required in order to work properly
+PIDFile=<WD>/shared/tmp/pids/puma.pid
+~~~~