genapi

type Caller interface {
	Call(ctx context.Context, res interface{}, method string, args interface{}) error
}

type CallerStub func(method string, args interface{}) (interface{}, error)

type GenAPI struct {
	// Required. Name is the name of the api, as it will be identified on the
	// command-line and in skyapi
	Name string

	// The set of rpc service structs which this API will host. Must have at
	// least one service in APIMode
	Services []interface{}

	// Like Services, but these will not be registered with the underlying
	// gateway library, and therefore will not show up in calls to
	// "RPC.GetMethods"
	HiddenServices []interface{}

	// The mux which the rpc services will be added to. If not set a new one
	// will be created and used. This can be used to provide extra functionality
	// in conjunction with the RPC server, or completely in place of it.
	//
	// It is important that RPCEndpoint does *not* have a handler set in this
	// mux, as GenAPI will be setting it itself.
	Mux *http.ServeMux

	// The http endpoint that the RPC handler for Services and HiddenServices
	// will be attached to. Defaults to "/". If you set this to "_", no rpc
	// listener will be set up and its up to you to add the handler from RPC()
	// to the mux for whatever path you need.
	RPCEndpoint string

	// Additional lever.Param structs which can be included in the lever parsing
	LeverParams []lever.Param

	// If mongo is intended to be used as a backend, this should be filled in
	*MongoInfo

	// If redis is intended to be used, this should be filled in.
	*RedisInfo

	// If okq is intended to be used, this should be filled in.
	*OkqInfo

	// If TLS is intended to be used, this should be filled in. The Certs field
	// of TLSInfo may be filled in during the Init function for convenience, but
	// the struct itself must be initialized before any of the Mode methods are
	// called
	*TLSInfo

	// A function to run just after initializing connections to backing
	// database. Meant for performing any initialization needed by the app.
	// This is called before any AppendInit functions
	Init InitFunc

	// May be set if a codec with different parameters is required.
	// If not set an rpcutil.LLCodec with default options will be used.
	Codec rpc.Codec

	// Do not set. This will be automatically filled in with whatever address
	// is being listened on once APIMode is called.
	ListenAddr string

	// Do not set. This will be automatically filled in when any of the run
	// modes are called, and may be used after that point to retrieve parameter
	// values.
	*lever.Lever

	// Do not set. This will be automatically filled in when any of the run
	// modes are called. Indicates which mode the GenAPI is currently in, and
	// may be used after that point to know which run mode GenAPI is in.
	Mode string

	// When initialized, this channel will be closed at the end of the init
	// phase of running. If in APIMode it will be closed just before the call to
	// ListenAndServe. This is useful so you can call APIMode in a separate
	// go-routine and know when it's started listening, if there's other steps
	// you want to take after initialization has been done.
	InitDoneCh chan bool

	// When initialized, this channel will be closed when in APIMode and cleanup
	// has been completed after a kill signal. This is useful if you have other
	// cleanup you want to run after GenAPI is done.
	DoneCh chan bool

	// Optional set of remote APIs (presumably GenAPIs, but that's not actually
	// required) that this one will be calling. The key should be the name of
	// the remote api, and the value should be the default address for it. Each
	// one will have a configuration option added for its address (e.g. if
	// "other-api" is in this list, then "--other-api-addr" will be a config
	// option). Each key can be used as an argument to RemoteAPICaller to obtain
	// a convenient function for communicating with other apis.
	RemoteAPIs map[string]string

	// Optional set of Healthers which should be checked during a /health-check.
	// These will be checked sequentially, and if any return an error that will
	// be logged and the health check will return false. The key in the map is a
	// name for the Healther which can be logged
	Healthers map[string]Healther

	// SRVClient which will be used by GenAPI when resolving requests, and which
	// can also be used by other processes as well. This should only be modified
	// during the init function
	*srvclient.SRVClient
	// contains filtered or unexported fields
}

type Healther interface {
	Healthy() error
}

type InitFunc func(*GenAPI)

type MongoInfo struct {
	// If you want to make mongo optional, set this and if --mongo-addr isn't
	// sent, then WithDB, WithColl will call fn with nil and SessionHelper's
	// session will be nil.
	Optional bool

	// The name of the mongo database this app should use. In TestMode this will
	// always be overwritten to "test_<DBName>"
	DBName string
	// contains filtered or unexported fields
}

type OkqInfo struct {
	// If you want to make okq optional, set this and if --okq-addr isn't sent,
	// Client will return nil
	Optional bool

	// Read/Write timeout for redis connection and the NotifyTimeout for Client.
	// Defaults to 30 seconds
	// Do not change after initializing GenAPI
	Timeout time.Duration

	*okq.Client
}

type RedisInfo struct {
	// If you want to make redis optional, set this and if --redis-addr isn't
	// sent, Cmder will be nil.
	Optional bool

	// Populated by the api once a connection to redis is made, and can be used
	// as such. Do not set manually.
	util.Cmder
}

type TLSInfo struct {
	// If set to true then the config options for passing in cert files on the
	// command-line will not be used, and instead the Certs field will be
	// expected to be filled in manually during the Init function
	FillCertsManually bool

	// One or more certificates to use for TLS. Will be filled automatically if
	// FillCertsManually is false
	Certs []tls.Certificate

	// SessionTicketKey is used by TLS servers to provide session
	// resumption. If multiple servers are terminating connections for the same
	// host they should all have the same SessionTicketKey. If the
	// SessionTicketKey leaks, previously recorded and future TLS connections
	// using that key are compromised.
	SessionTicketKey [32]byte

	// If set then this config will be used for all tls listeners, regardless of
	// all other factors.
	//
	// NOTE: remember that you probably need to call BuildNameToCertificate on
	// the Config you make
	// NOTE2: you'll need to handle creation of SessionTicketKey yourself as well
	ForceTLSConfig *tls.Config
}