provider

type Config struct {
	// Service is the name to identify the client.
	Service string

	// Resource contains information about the Resource the provider will
	// register as.
	Resource cloud.HashicorpCloudLocationLink

	// HCPConfig is the HCP specific configuration, it provides information
	// necessary to talk to HCP APIs.
	HCPConfig sdk.HCPConfig

	// Logger is the Logger to use for logs.
	Logger hclog.Logger

	// TestBackoff is used to force the provider to retry more aggressively.
	TestBackoff time.Duration
}

type ConnectRequest struct {
	Capability string
	Meta       map[string]string

	Severity string
	Message  string
}

type ConnectResponse struct {
	Success bool
}

type DisconnectRequest struct {
	NoRetry bool          // Should the client retry
	Backoff time.Duration // Minimum backoff
	Reason  string
}

type DisconnectResponse struct {
}

type Meta struct {
	Key, Value string
}

type Provider struct {
	// contains filtered or unexported fields
}

type SCADAProvider interface {
	// UpdateMeta overwrites the internal map of meta-data values
	// and performs a re-handshake to update the remote broker.
	UpdateMeta(map[string]string)

	// AddMeta upserts keys and values in the internal map of meta-data
	// and performs a re-handshake to update the remote broker.
	AddMeta(...Meta)

	// DeleteMeta delete keys from the meta-date values and then perform a
	// re-handshake to update the remote broker.
	DeleteMeta(...string)

	// GetMeta returns the provider's current meta-data.
	GetMeta() map[string]string

	// Listen will expose the provided capability and make new connections
	// available through the returned listener. Closing the listener will stop
	// exposing the provided capability.
	//
	// The method will return an existing listener if the capability already existed.
	// Listeners can be retrieved even when the provider is stopped (e.g. before it is
	// started). New capabilities and new-meta data can be added at any time.
	//
	// The listener will only be closed, if it is closed explicitly by calling Close().
	// The listener will not be closed due to errors or when the provider is stopped.
	// The listener can hence be used after a restart of the provider.
	Listen(capability string) (net.Listener, error)

	// Start will register the provider on the SCADA broker and expose the
	// registered capabilities.
	Start() error

	// Stop will try to gracefully close the currently active SCADA session. This will
	// not close the capability listeners.
	Stop() error

	// SessionStatus returns the status of the SCADA connection.
	//
	// The possibles statuses are:
	//   - SessionStatusDisconnected: the provider is stopped
	//   - SessionStatusConnecting:   in the connect/handshake cycle
	//   - SessionStatusConnected:    connected and serving scada consumers
	//   - SessionStatusWaiting:      disconnected and waiting to retry a connection to the broker
	//
	// The full lifecycle is: connecting -> connected -> waiting -> connecting -> ... -> disconnected.
	SessionStatus() SessionStatus

	// LastError returns the last error recorded in the provider
	// connection state engine as well as the time at which the error occured.
	// That record is erased at each occasion when the provider achieves a new connection.
	//
	// A few common internal error will return a known type:
	//   - ErrProviderNotStarted: the provider is not started
	//   - ErrInvalidCredentials: could not obtain a token with the supplied credentials
	//   - ErrPermissionDenied:   principal does not have the permision to register as a provider
	//
	// Any other internal error will be returned directly and unchanged.
	LastError() (time.Time, error)

	// UpdateConfig overwrites the provider's configuration with the given configuration.
	UpdateConfig(config *Config) error
}

type SessionStatus = string