_load_from(path)
click to toggle source
def _load_from(path)
instance_eval File.read(path), path, 1
end
activate_control_app(url="auto", opts=nil)
click to toggle source
Start the Puma control rack app on
url. This app can be communicated with to control the main server.
def activate_control_app(url="auto", opts=nil)
@options[:control_url] = url
if opts
if tok = opts[:auth_token]
@options[:control_auth_token] = tok
end
if opts[:no_token]
@options[:control_auth_token] = :none
end
end
end
app(obj=nil, &block)
click to toggle source
Use obj or block as the Rack app. This allows a config file to be the
app itself.
def app(obj=nil, &block)
obj ||= block
raise "Provide either a #call'able or a block" unless obj
@options[:app] = obj
end
bind(url)
click to toggle source
Bind the server to url. tcp:// and unix:// are the only accepted
protocols.
def bind(url)
@options[:binds] << url
end
daemonize(which=true)
click to toggle source
Daemonize the server into the background. Highly suggest that this be
combined with pidfile and stdout_redirect.
def daemonize(which=true)
@options[:daemon] = which
end
directory(dir)
click to toggle source
The directory to operate out of.
def directory(dir)
@options[:directory] = dir.to_s
@options[:worker_directory] = dir.to_s
end
drain_on_shutdown(which=true)
click to toggle source
When shutting down, drain the accept socket of pending connections and
proces them. This loops over the accept socket until there are no more read
events and then stops looking and waits for the requests to finish.
def drain_on_shutdown(which=true)
@options[:drain_on_shutdown] = which
end
environment(environment)
click to toggle source
Set the environment in which the Rack's app will run.
def environment(environment)
@options[:environment] = environment
end
on_restart(&block)
click to toggle source
Code to run before doing a restart. This code should close logfiles,
database connections, etc.
This can be called multiple times to add code each time.
def on_restart(&block)
@options[:on_restart] << block
end
on_worker_boot(&block)
click to toggle source
*Cluster mode only* Code to run when a worker
boots to setup the process before booting the app.
This can be called multiple times to add hooks.
def on_worker_boot(&block)
@options[:worker_boot] << block
end
pidfile(path)
click to toggle source
Store the pid of the server in the file at path.
def pidfile(path)
@options[:pidfile] = path
end
port(port)
click to toggle source
Define the TCP port to bind to. Use bind for more advanced
options.
def port(port)
@options[:binds] << "tcp://#{Configuration::DefaultTCPHost}:#{port}"
end
preload_app!(answer=true)
click to toggle source
*Cluster mode only* Preload the application
before starting the workers and setting up the listen ports. This conflicts
with using the phased restart feature, you can't use both.
def preload_app!(answer=true)
@options[:preload_app] = answer
end
quiet()
click to toggle source
Disable request logging.
def quiet
@options[:quiet] = true
end
rackup(path)
click to toggle source
Load path as a rackup file.
def rackup(path)
@options[:rackup] = path.to_s
end
restart_command(cmd)
click to toggle source
Command to use to restart puma. This should be just how to load puma itself
(ie. 'ruby -Ilib bin/puma'), not the arguments to puma, as those are the
same as the original process.
def restart_command(cmd)
@options[:restart_cmd] = cmd
end
ssl_bind(host, port, opts)
click to toggle source
def ssl_bind(host, port, opts)
o = [
"cert=#{opts[:cert]}",
"key=#{opts[:key]}"
]
@options[:binds] << "ssl://#{host}:#{port}?#{o.join('&')}"
end
state_path(path)
click to toggle source
Use path as the file to store the server info state. This is used
by pumactl to query and control the server.
def state_path(path)
@options[:state] = path.to_s
end
stdout_redirect(stdout=nil, stderr=nil, append=false)
click to toggle source
Redirect STDOUT and STDERR to files specified.
def stdout_redirect(stdout=nil, stderr=nil, append=false)
@options[:redirect_stdout] = stdout
@options[:redirect_stderr] = stderr
@options[:redirect_append] = append
end
tcp_mode()
click to toggle source
Run the app as a raw TCP app instead of an HTTP rack app
def tcp_mode
@options[:mode] = :tcp
end
threads(min, max)
click to toggle source
Configure min to be the minimum number of threads to use to answer
requests and max the maximum.
def threads(min, max)
min = Integer(min)
max = Integer(max)
if min > max
raise "The minimum (#{min}) number of threads must be less than the max (#{max})"
end
@options[:min_threads] = min
@options[:max_threads] = max
end
workers(count)
click to toggle source
*Cluster mode only* How many worker processes
to run.
def workers(count)
@options[:workers] = count.to_i
end
![[+]](../../images/find.png "show/hide quicksearch")