Falcon and Async#close

[tleish]

When using async gems (e.g. async-http or async-redis) as part of a falcon request, is #close necessary for each request, or will the connections auto-close as part of falcon?

e.g.

def anything
	internet = Async::HTTP::Internet.new
	headers = [['accept', 'application/json']]
	body = [JSON.dump(data)]
	internet.post("https://httpbin.org/anything", headers, body)
ensure
	internet.close
end

or

def something
	endpoint = Async::Redis.local_endpoint
	client = Async::Redis::Client.new(endpoint)
	client.set('X', 10)
ensure
	client.close
end

[ioquatix]

This is a very good question.

I think in an ideal world, you keep connections open until the remote end closes, or you hit some internal timeout.

The value of a persistent connection is that it reduces the overhead of an individual request.

So, if you want to minimise resource usage, calling close is okay. The cost is a bit more churn when it comes to making requests.

The implementation/responsibility for this probably falls into async-pool. It probably does make sense to add some kind of reaper. We already know usage, but we don't keep time since last used.

class Reaper
	def initialize(controller, duration = 60)
		@controller = controller
		@duration = duration
		
		@reaper = Async do |task|
			while @pool
				task.sleep(@duration)
				
				@controller.resources.delete_if do |resource, usage|
					if usage.zero?
						resource.close || true
					end
				end
			end
		end
	end
	
	def close
		@controller = nil
		@reaper&.stop
		@reaper = nil
	end
end

There are other potential implementations... Rather than using a timer, you could:

1. On acquiring a new connection, flush any old connections except for the one you are about to return.
2. On releasing a connection, free it if it's beyond some defined limit, e.g. 1 open connection.

I welcome any ideas, but this issue is largely addressed by the above feedback, I'll close it, and instead open an issue on async-pool which is where any potential work should be done.

[tleish]

So, it sounds like "ensuring" a connection to close is not necessary. If not closing, is it possible to run out of connections?

FYI, I prefer the simpler route and not have to worry about closing a connection (which is how most other ruby clients work).

[ioquatix]

So, it sounds like "ensuring" a connection to close is not necessary. If not closing, is it possible to run out of connections?

If you create a new pool per request, you absolutely must close it or you will leak resources. So your proposed code was correct.

The other alternative is to assign it to an instance variable and reuse it.

Unfortunately in highly concurrent servers like Falcon, it does become necessary to explicitly manage resources. The default in async-redis is to allow unlimited number of upstream connections.

You control this by by Async::Redis::Client.new(limit: 4). This will limit to 4 simultaneous connections.

FYI, I prefer the simpler route and not have to worry about closing a connection (which is how most other ruby clients work).

To be frank, most other clients don't support persistent connections, so the chance of leaking resources is limited.

[ioquatix]

The reaper in async-pool will close connections when the async loop goes out of scope. This gives you basic life-cycle management, but for long running processes like falcon, explicitly closing resources is necessary to prevent exhaustion.