network-wait: Lightweight library for waiting on networked services to become available.

[ library, mit, network ] [ Propose Tags ] [ Report a vulnerability ]

Please see the README on GitHub at https://github.com/mbg/network-wait#readme


[Skip to Readme]

Modules

[Index] [Quick Jump]

  • Network

Flags

Manual Flags

NameDescriptionDefault
postgres

Enable Postgres support.

Disabled
redis

Enable Redis support.

Disabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.2.0.0
Change log ChangeLog.md
Dependencies base (>=4.7 && <5), exceptions, network, retry [details]
License MIT
Copyright 2022 Michael B. Gale
Author Michael B. Gale
Maintainer github@michael-gale.co.uk
Category Network
Home page https://github.com/mbg/network-wait#readme
Bug tracker https://github.com/mbg/network-wait/issues
Source repo head: git clone https://github.com/mbg/network-wait
Uploaded by mbg at 2022-05-12T14:17:39Z
Distributions LTSHaskell:0.2.0.0, NixOS:0.2.0.0, Stackage:0.2.0.0
Downloads 1051 total (26 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2022-05-12 [all 1 reports]

Readme for network-wait-0.2.0.0

[back to package description]

network-wait

MIT CI Hackage

A lightweight Haskell library for waiting on networked services to become available. This is useful if you are e.g. building a web application which relies on a database server to be available, but which may not be immediately available on application startup.

Example

All functions provided by this library work with retry policies from Control.Retry which provide good control over the retry behaviour. To wait for a PostgreSQL server to become available on the same machine:

import Control.Retry
import Network.Wait

main :: IO ()
main = do
    waitTcp retryPolicyDefault "localhost" "5432"
    putStrLn "Yay, the server is available!"

The haddock documentation for this library contains more examples.

Example: PostgreSQL

The network-wait package can be compiled with the network-wait:postgres flag (e.g. stack build --flag network-wait:postgres) which enables support for checking the readiness of PostgreSQL servers specifically. Unlike the functions in the Network.Wait module, which only check that connections can be established, the functions in Network.Wait.PostgreSQL also check that a PostgreSQL server is ready to accept commands. To wait for a PostgreSQL server to become available and accept commands:

import Control.Retry (retryPolicyDefault)
import Database.PostgreSQL.Simple (defaultConnectInfo)
import Network.Wait.PostgreSQL (waitPostgreSQL)

main :: IO ()
main = do
    waitPostgreSQL retryPolicyDefault defaultConnectInfo
    putStrLn "Yay, the PostgreSQL server is ready to accept commands!"

Internally, this uses postgresql-simple to connect to the specified server (defaultConnectInfo in the example above) and send a SELECT 1; query. If the query is answered correctly, we consider the server to be in a state ready to accept commands.

The Network.Wait.PostgreSQL module is gated behind the network-wait:postgres flag so that the PostgreSQL-specific dependencies are only required when PostgresSQL support is required by users of this library.

Example: Redis

The network-wait package can be compiled with the network-wait:redis flag (e.g. stack build --flag network-wait:redis) which enables support for checking the readiness of Redis servers specifically. Unlike the functions in the Network.Wait module, which only check that connections can be established, the functions in Network.Wait.Redis also check that a Redis server is ready to accept commands. To wait for a Redis server to become available and accept commands:

import Control.Retry (retryPolicyDefault)
import Database.Redis (defaultConnectInfo)
import Network.Wait.Redis (waitRedis)

main :: IO ()
main = do
    waitRedis retryPolicyDefault defaultConnectInfo
    putStrLn "Yay, the Redis server is ready to accept commands!"

Internally, this uses hedis to connect to the specified server (defaultConnectInfo in the example above) and send a ping. If the ping is answered, we consider the server to be in a state ready to accept commands.

The Network.Wait.Redis module is gated behind the network-wait:redis flag so that the Redis-specific dependencies are only required when Redis support is required by users of this library.

See also

  • wait-for is a popular shell script with the same objectives as this library.
  • The port-utils package has some functions for waiting on TCP servers to become available, with a fixed timeout.