connection.rb
initialize
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/connection.rb
in
initialize
# See also DataObjects::Pooling and DataObjects::Logger
def self.inherited(target)
target.class_eval do
# Allocate a Connection object from the pool, creating one if necessary. This method is active in Connection subclasses only.
def self.new(*args)
instance = allocate
instance.send(:initialize, *args)
instance
end
include Quoting
end
if driver_module_name = target.name.split('::')[-2]
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/connection.rb
in
new
# See also DataObjects::Pooling and DataObjects::Logger
def self.inherited(target)
target.class_eval do
# Allocate a Connection object from the pool, creating one if necessary. This method is active in Connection subclasses only.
def self.new(*args)
instance = allocate
instance.send(:initialize, *args)
instance
end
include Quoting
end
if driver_module_name = target.name.split('::')[-2]
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/pooling.rb
in
block in new
instance = nil
begin
lock.synchronize do
if @available.size > 0
instance = @available.pop
@used[instance.object_id] = instance
elsif @used.size < @max_size
instance = @resource.__new(*@args)
raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
instance.instance_variable_set(:@__pool, self)
instance.instance_variable_set(:@__allocated_in_pool, Time.now)
@used[instance.object_id] = instance
else
# Wait for another thread to release an instance.
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/pooling.rb
in
new
def scavenge_interval
@resource.scavenge_interval
end
def new
instance = nil
begin
lock.synchronize do
if @available.size > 0
instance = @available.pop
@used[instance.object_id] = instance
elsif @used.size < @max_size
instance = @resource.__new(*@args)
raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/pooling.rb
in
new
end
def self.__pool_wait
@__pool_wait
end
def self.new(*args)
(@__pools[args] ||= __pool_lock.synchronize { Pool.new(self.pool_size, self, args) }).new
end
def self.__pools
@__pools
end
def self.pool_size
/app/vendor/bundle/ruby/1.9.1/gems/data_objects-0.10.6/lib/data_objects/connection.rb
in
new
else
clazz.class_eval do
include Pooling
alias close release
end
end
end
clazz.new(conn_uri)
end
# Ensure that all Connection subclasses handle pooling and logging uniformly.
# See also DataObjects::Pooling and DataObjects::Logger
def self.inherited(target)
target.class_eval do
/app/vendor/bundle/ruby/1.9.1/gems/dm-do-adapter-1.1.0/lib/dm-do-adapter/adapter.rb
in
open_connection
chainable do
protected
# Instantiates new connection object
#
# @api semipublic
def open_connection
DataObjects::Connection.new(normalized_uri)
end
# Takes connection and closes it
#
# @api semipublic
def close_connection(connection)
connection.close if connection.respond_to?(:close)
/app/vendor/bundle/ruby/1.9.1/gems/dm-transactions-1.1.0/lib/dm-transactions/adapters/dm-do-adapter.rb
in
open_connection
end
chainable do
protected
# @api semipublic
def open_connection
current_connection || super
end
# @api semipublic
def close_connection(connection)
super unless current_connection.equal?(connection)
end
end
/app/vendor/bundle/ruby/1.9.1/gems/dm-do-adapter-1.1.0/lib/dm-do-adapter/adapter.rb
in
with_connection
if driver_module = DataObjects.const_get(normalized_uri.scheme.capitalize)
driver_module.logger = DataMapper.logger if driver_module.respond_to?(:logger=)
end
end
# @api private
def with_connection
yield connection = open_connection
rescue Exception => exception
DataMapper.logger.error(exception.to_s) if DataMapper.logger
raise
ensure
close_connection(connection)
end
/app/vendor/bundle/ruby/1.9.1/gems/dm-aggregates-1.1.0/lib/dm-aggregates/adapters/dm-do-adapter.rb
in
aggregate
fields = query.fields
types = fields.map { |p| p.respond_to?(:operator) ? String : p.primitive }
field_size = fields.size
records = []
with_connection do |connection|
statement, bind_values = select_statement(query)
command = connection.create_command(statement)
command.set_types(types)
reader = command.execute_reader(*bind_values)
/app/vendor/bundle/ruby/1.9.1/gems/dm-aggregates-1.1.0/lib/dm-aggregates/repository.rb
in
aggregate
module DataMapper
module Aggregates
module Repository
def aggregate(query)
unless query.valid?
[]
else
adapter.aggregate(query)
end
end
end
end
end
/app/vendor/bundle/ruby/1.9.1/gems/dm-aggregates-1.1.0/lib/dm-aggregates/functions.rb
in
aggregate
end
query = scoped_query(query)
if query.fields.any? { |p| p.kind_of?(Property) }
query.repository.aggregate(query.update(:unique => true))
else
query.repository.aggregate(query).first # only return one row
end
end
private
def assert_property_type(name, *types)
if name.nil?
/app/vendor/bundle/ruby/1.9.1/gems/dm-aggregates-1.1.0/lib/dm-aggregates/functions.rb
in
sum
# @api public
def sum(*args)
query = args.last.kind_of?(::Hash) ? args.pop : {}
property_name = args.first
assert_property_type property_name, ::Integer, ::Float, ::BigDecimal
aggregate(query.merge(:fields => [ property_name.sum ]))
end
# Perform aggregate queries
#
# @example the count of friends
# Friend.aggregate(:all.count)
#
/app/lib/chicago_lobbyists/application.rb
in
block in <class:Application>
@current_menu = "lobbyists"
@lobbyists = Lobbyist.list_by_compensation :limit => (params[:size] || size), :offset => (params[:page] || page)
erb :lobbyists
end
get "/lobbyists/:id" do
@total_paid = "%.2f" % Compensation.sum(:compensation)
@lobbyist = Lobbyist.first :slug => params[:id]
@page_title = "#{@lobbyist.first_name} #{@lobbyist.last_name} - Lobbyist"
@current_menu = "lobbyists"
@actions = @lobbyist.actions.sort_by { |action| action.purpose }
@agency_actions = @lobbyist.actions.group_by { |action|
action.agency
}.sort_by { |agency, actions| agency.name }
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
call
unbound_method = instance_method method_name
pattern, keys = compile(path)
conditions, @conditions = @conditions, []
remove_method method_name
[ block.arity != 0 ?
proc { unbound_method.bind(self).call(*@block_params) } :
proc { unbound_method.bind(self).call },
pattern, keys, conditions ]
end
def compile(path)
keys = []
if path.respond_to? :to_str
special_chars = %w{. + ( ) $}
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in compile!
unbound_method = instance_method method_name
pattern, keys = compile(path)
conditions, @conditions = @conditions, []
remove_method method_name
[ block.arity != 0 ?
proc { unbound_method.bind(self).call(*@block_params) } :
proc { unbound_method.bind(self).call },
pattern, keys, conditions ]
end
def compile(path)
keys = []
if path.respond_to? :to_str
special_chars = %w{. + ( ) $}
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
instance_eval
route_eval(&pass_block) if pass_block
route_missing
end
# Run a route block and throw :halt with the result.
def route_eval(&block)
throw :halt, instance_eval(&block)
end
# If the current request matches pattern and conditions, fill params
# with keys and call the given block.
# Revert params afterwards.
#
# Returns pass block.
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
route_eval
route_eval(&pass_block) if pass_block
route_missing
end
# Run a route block and throw :halt with the result.
def route_eval(&block)
throw :halt, instance_eval(&block)
end
# If the current request matches pattern and conditions, fill params
# with keys and call the given block.
# Revert params afterwards.
#
# Returns pass block.
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block (2 levels) in route!
end
# Run routes defined on the class and all superclasses.
def route!(base = settings, pass_block=nil)
if routes = base.routes[@request.request_method]
routes.each do |pattern, keys, conditions, block|
pass_block = process_route(pattern, keys, conditions) do
route_eval(&block)
end
end
end
# Run routes defined in superclass.
if base.superclass.respond_to?(:routes)
return route!(base.superclass, pass_block)
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in process_route
{}
end
@params = @original_params.merge(params)
@block_params = values
catch(:pass) do
conditions.each { |cond|
throw :pass if instance_eval(&cond) == false }
yield
end
end
ensure
@params = @original_params
end
# No matching route was found or all routes passed. The default
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
catch
elsif values.any?
{'captures' => values}
else
{}
end
@params = @original_params.merge(params)
@block_params = values
catch(:pass) do
conditions.each { |cond|
throw :pass if instance_eval(&cond) == false }
yield
end
end
ensure
@params = @original_params
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
process_route
elsif values.any?
{'captures' => values}
else
{}
end
@params = @original_params.merge(params)
@block_params = values
catch(:pass) do
conditions.each { |cond|
throw :pass if instance_eval(&cond) == false }
yield
end
end
ensure
@params = @original_params
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in route!
base.filters[type].each { |block| instance_eval(&block) }
end
# Run routes defined on the class and all superclasses.
def route!(base = settings, pass_block=nil)
if routes = base.routes[@request.request_method]
routes.each do |pattern, keys, conditions, block|
pass_block = process_route(pattern, keys, conditions) do
route_eval(&block)
end
end
end
# Run routes defined in superclass.
if base.superclass.respond_to?(:routes)
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
each
filter! type, base.superclass if base.superclass.respond_to?(:filters)
base.filters[type].each { |block| instance_eval(&block) }
end
# Run routes defined on the class and all superclasses.
def route!(base = settings, pass_block=nil)
if routes = base.routes[@request.request_method]
routes.each do |pattern, keys, conditions, block|
pass_block = process_route(pattern, keys, conditions) do
route_eval(&block)
end
end
end
# Run routes defined in superclass.
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
route!
filter! type, base.superclass if base.superclass.respond_to?(:filters)
base.filters[type].each { |block| instance_eval(&block) }
end
# Run routes defined on the class and all superclasses.
def route!(base = settings, pass_block=nil)
if routes = base.routes[@request.request_method]
routes.each do |pattern, keys, conditions, block|
pass_block = process_route(pattern, keys, conditions) do
route_eval(&block)
end
end
end
# Run routes defined in superclass.
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
dispatch!
res
end
# Dispatch a request with error handling.
def dispatch!
static! if settings.static? && (request.get? || request.head?)
filter! :before
route!
rescue NotFound => boom
handle_not_found!(boom)
rescue ::Exception => boom
handle_exception!(boom)
ensure
filter! :after unless env['sinatra.static_file']
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in call!
@response = Response.new
@params = indifferent_params(@request.params)
template_cache.clear if settings.reload_templates
force_encoding(@request.route)
force_encoding(@params)
@response['Content-Type'] = nil
invoke { dispatch! }
invoke { error_block!(response.status) }
unless @response['Content-Type']
if body.respond_to?(:to_ary) and body.first.respond_to? :content_type
content_type body.first.content_type
else
content_type :html
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
instance_eval
# Creates a Hash with indifferent access.
def indifferent_hash
Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
end
# Run the block with 'throw :halt' support and apply result to the response.
def invoke(&block)
res = catch(:halt) { instance_eval(&block) }
return if res.nil?
case
when res.respond_to?(:to_str)
@response.body = [res]
when res.respond_to?(:to_ary)
res = res.to_ary
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in invoke
# Creates a Hash with indifferent access.
def indifferent_hash
Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
end
# Run the block with 'throw :halt' support and apply result to the response.
def invoke(&block)
res = catch(:halt) { instance_eval(&block) }
return if res.nil?
case
when res.respond_to?(:to_str)
@response.body = [res]
when res.respond_to?(:to_ary)
res = res.to_ary
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
catch
# Creates a Hash with indifferent access.
def indifferent_hash
Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
end
# Run the block with 'throw :halt' support and apply result to the response.
def invoke(&block)
res = catch(:halt) { instance_eval(&block) }
return if res.nil?
case
when res.respond_to?(:to_str)
@response.body = [res]
when res.respond_to?(:to_ary)
res = res.to_ary
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
invoke
# Creates a Hash with indifferent access.
def indifferent_hash
Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
end
# Run the block with 'throw :halt' support and apply result to the response.
def invoke(&block)
res = catch(:halt) { instance_eval(&block) }
return if res.nil?
case
when res.respond_to?(:to_str)
@response.body = [res]
when res.respond_to?(:to_ary)
res = res.to_ary
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
call!
@response = Response.new
@params = indifferent_params(@request.params)
template_cache.clear if settings.reload_templates
force_encoding(@request.route)
force_encoding(@params)
@response['Content-Type'] = nil
invoke { dispatch! }
invoke { error_block!(response.status) }
unless @response['Content-Type']
if body.respond_to?(:to_ary) and body.first.respond_to? :content_type
content_type body.first.content_type
else
content_type :html
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
call
@app = app
@template_cache = Tilt::Cache.new
yield self if block_given?
end
# Rack call interface.
def call(env)
dup.call!(env)
end
attr_accessor :env, :request, :response, :params
def call!(env) # :nodoc:
@env = env
@request = Request.new(env)
/app/vendor/bundle/ruby/1.9.1/gems/rack-1.3.1/lib/rack/head.rb
in
call
class Head
def initialize(app)
@app = app
end
def call(env)
status, headers, body = @app.call(env)
if env["REQUEST_METHOD"] == "HEAD"
[status, headers, []]
else
[status, headers, body]
end
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/showexceptions.rb
in
call
def initialize(app)
@app = app
@template = ERB.new(TEMPLATE)
end
def call(env)
@app.call(env)
rescue Exception => e
errors, env["rack.errors"] = env["rack.errors"], @@eats_errors
if respond_to?(:prefers_plain_text?) and prefers_plain_text?(env)
content_type = "text/plain"
body = [dump_exception(e)]
else
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
block in call
setup_sessions builder
middleware.each { |c,a,b| builder.use(c, *a, &b) }
builder.run new!(*args, &bk)
builder
end
def call(env)
synchronize { prototype.call(env) }
end
private
def setup_sessions(builder)
return unless sessions?
builder.use Rack::Session::Cookie, :secret => session_secret
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
synchronize
end
@@mutex = Mutex.new
def synchronize(&block)
if lock?
@@mutex.synchronize(&block)
else
yield
end
end
def metadef(message, &block)
(class << self; self; end).
send :define_method, message, &block
end
/app/vendor/bundle/ruby/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb
in
call
setup_sessions builder
middleware.each { |c,a,b| builder.use(c, *a, &b) }
builder.run new!(*args, &bk)
builder
end
def call(env)
synchronize { prototype.call(env) }
end
private
def setup_sessions(builder)
return unless sessions?
builder.use Rack::Session::Cookie, :secret => session_secret
end
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/connection.rb
in
block in pre_process
# When we're under a non-async framework like rails, we can still spawn
# off async responses using the callback info, so there's little point
# in removing this.
response = AsyncResponse
catch(:async) do
# Process the request calling the Rack adapter
response = @app.call(@request.env)
end
response
rescue Exception
handle_error
terminate_request
nil # Signal to post_process that the request could not be processed
end
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/connection.rb
in
catch
# callback is no longer referenced, so be tidy!
@request.async_callback = method(:post_process)
# When we're under a non-async framework like rails, we can still spawn
# off async responses using the callback info, so there's little point
# in removing this.
response = AsyncResponse
catch(:async) do
# Process the request calling the Rack adapter
response = @app.call(@request.env)
end
response
rescue Exception
handle_error
terminate_request
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/connection.rb
in
pre_process
# callback is no longer referenced, so be tidy!
@request.async_callback = method(:post_process)
# When we're under a non-async framework like rails, we can still spawn
# off async responses using the callback info, so there's little point
# in removing this.
response = AsyncResponse
catch(:async) do
# Process the request calling the Rack adapter
response = @app.call(@request.env)
end
response
rescue Exception
handle_error
terminate_request
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/connection.rb
in
process
# is ready to be processed.
def process
if threaded?
@request.threaded = true
EventMachine.defer(method(:pre_process), method(:post_process))
else
@request.threaded = false
post_process(pre_process)
end
end
def pre_process
# Add client info to the request env
@request.remote_address = remote_address
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/connection.rb
in
receive_data
@request = Request.new
@response = Response.new
end
# Called when data is received from the client.
def receive_data(data)
trace { data }
process if @request.parse(data)
rescue InvalidRequest => e
log "!! Invalid request"
log_error e
close_connection
end
# Called when all data was received and the request
/app/vendor/bundle/ruby/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb
in
run_machine
@reactor_running = true
initialize_event_machine
(b = blk || block) and add_timer(0, b)
if @next_tick_queue && !@next_tick_queue.empty?
add_timer(0) { signal_loopbreak }
end
@reactor_thread = Thread.current
run_machine
ensure
until @tails.empty?
@tails.pop.call
end
begin
release_machine
/app/vendor/bundle/ruby/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb
in
run
@reactor_running = true
initialize_event_machine
(b = blk || block) and add_timer(0, b)
if @next_tick_queue && !@next_tick_queue.empty?
add_timer(0) { signal_loopbreak }
end
@reactor_thread = Thread.current
run_machine
ensure
until @tails.empty?
@tails.pop.call
end
begin
release_machine
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/backends/base.rb
in
start
@running = true
end
# Allow for early run up of eventmachine.
if EventMachine.reactor_running?
starter.call
else
EventMachine.run(&starter)
end
end
# Stop of the backend from accepting new connections.
def stop
@running = false
@stopping = true
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/server.rb
in
start
log ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
debug ">> Debugging ON"
trace ">> Tracing ON"
log ">> Maximum connections set to #{@backend.maximum_connections}"
log ">> Listening on #{@backend}, CTRL+C to stop"
@backend.start
end
alias :start! :start
# == Gracefull shutdown
# Stops the server after processing all current connections.
# As soon as this method is called, the server stops accepting
# new requests and wait for all current connections to finish.
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/controllers/controller.rb
in
start
# If a stats URL is specified, wrap in Stats adapter
server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
# Register restart procedure which just start another process with same options,
# so that's why this is done here.
server.on_restart { Command.run(:start, @options) }
server.start
end
def stop
raise OptionRequired, :pid unless @options[:pid]
tail_log(@options[:log]) do
if Server.kill(@options[:pid], @options[:force] ? 0 : (@options[:timeout] || 60))
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/runner.rb
in
run_command
when cluster? then Controllers::Cluster.new(@options)
when service? then Controllers::Service.new(@options)
else Controllers::Controller.new(@options)
end
if controller.respond_to?(@command)
begin
controller.send(@command, *@arguments)
rescue RunnerError => e
abort e.message
end
else
abort "Invalid options for command: #{@command}"
end
end
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/lib/thin/runner.rb
in
run!
@arguments = @argv
end
# Parse the current shell arguments and run the command.
# Exits on error.
def run!
if self.class.commands.include?(@command)
run_command
elsif @command.nil?
puts "Command required"
puts @parser
exit 1
else
abort "Unknown command: #{@command}. Use one of #{self.class.commands.join(', ')}"
end
/app/vendor/bundle/ruby/1.9.1/gems/thin-1.2.7/bin/thin
in
<top (required)>
#!/usr/bin/env ruby
# Thin command line interface script.
# Run <tt>thin -h</tt> to get more usage.
require 'thin'
Thin::Runner.new(ARGV).run!
/app/vendor/bundle/ruby/1.9.1/bin/thin
in
load
if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
version = $1
ARGV.shift
end
gem 'thin', version
load Gem.bin_path('thin', 'thin', version)
/app/vendor/bundle/ruby/1.9.1/bin/thin
in
<main>
if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
version = $1
ARGV.shift
end
gem 'thin', version
load Gem.bin_path('thin', 'thin', version)
No GET data.
No POST data.
Variable | Value |
---|---|
GATEWAY_INTERFACE | CGI/1.2 |
HTTP_ACCEPT | */* |
HTTP_CONNECTION | close |
HTTP_CONNECT_TIME | 0 |
HTTP_HOST | chicagolobbyists.org |
HTTP_TOTAL_ROUTE_TIME | 0 |
HTTP_USER_AGENT | claudebot |
HTTP_VERSION | HTTP/1.1 |
HTTP_VIA | 1.1 vegur |
HTTP_X_FORWARDED_FOR | 34.201.19.151 |
HTTP_X_FORWARDED_PORT | 80 |
HTTP_X_FORWARDED_PROTO | http |
HTTP_X_REQUEST_ID | 735e8545-6437-4ec2-8df2-cf70efdcdb5b |
HTTP_X_REQUEST_START | 1711727911708 |
PATH_INFO | /lobbyists/robert-molaro |
QUERY_STRING | |
REMOTE_ADDR | 10.1.17.137 |
REQUEST_METHOD | GET |
REQUEST_PATH | /lobbyists/robert-molaro |
REQUEST_URI | /lobbyists/robert-molaro |
SCRIPT_NAME | |
SERVER_NAME | chicagolobbyists.org |
SERVER_PORT | 80 |
SERVER_PROTOCOL | HTTP/1.1 |
SERVER_SOFTWARE | thin 1.2.7 codename No Hup |
async.callback | #<Method: Thin::Connection#post_process> |
async.close | #<EventMachine::DefaultDeferrable:0x00000004ce75a8> |
rack.errors | #<Object:0x00000002d06040> |
rack.input | #<StringIO:0x00000004ce7df0> |
rack.multiprocess | false |
rack.multithread | false |
rack.request.query_hash | {} |
rack.request.query_string | |
rack.run_once | false |
rack.url_scheme | http |
rack.version | [1, 0] |
sinatra.error | #<DataObjects::ConnectionError: could not connect to server: Connection refused
Is the server running on host "localhost" (127.0.0.1) and accepting
TCP/IP connections on port 5432?
(code: , sql state: , query: , uri: )> |
You're seeing this error because you have
enabled the show_exceptions
setting.