service

type Initializer interface {
	// Initialize is called before the server is in a live state and the server is not
	// serving any requests (unhealthy, no liveness probes) and is the first possible
	// entry point to the service interface. If an error is returned from Initialize,
	// the server will not start at all.
	Initialize() error
}

type Option func(*options)

type Preparer interface {
	// Setup is called after initialize and after the server has started serving
	// liveness probes (e.g. it is healthy but not ready). It is called prior to routes
	// and is intended for more general setup and connection to databases and other
	// resources. If an error is returned, the server will shutdown and will not proceed
	// with its startup. Retry logic to delay readiness should be added to this method.
	Setup() error
}

type Server struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type Service interface {
	// Routes is called once the server is up and running and is in a live state but
	// before it is in a ready state. The intended use case of this method is for the
	// Service to specify its own middleware, routes, and handlers on the router, which
	// is the majority of what differentiates a service from the main server.
	// If an error is returned, the error will shutdown the server and stop startup.
	Routes(router *gin.Engine) error

	// Stop is called after the http server has gracefully concluded serving and the
	// service is in a not ready, not healthy state. This method should be used to
	// clean up connections to databases, close resources properly, etc. Note that the
	// context may have a deadline on it before the server is terminated.
	// If an error is returned, the error will be reported to the caller of Serve().
	Stop(ctx context.Context) error
}

type Starter interface {
	// Started is called after the server is serving and ready, after the Routes method
	// has been called. Errors returned from this function will cause the server to
	// shutdown will will have the effect of calling the services Shutdown method as
	// well. Any errors returned from shutdown or this method are returned as a
	// multierror to report everything that happened in the error process. This method
	// is generally used for logging or booting up background routines and is a good
	// choice for work that needs to be done that is error prone but may not affect the
	// service or the ability of the service to handle requests.
	Started() error
}