apiserver

type CharmsHTTPHandler struct {
	PostHandler FailableHandlerFunc
	GetHandler  FailableHandlerFunc
}

type Collector struct {
	BuildInfo        prometheus.Gauge
	TotalConnections prometheus.Counter

	LoginAttempts      prometheus.Gauge
	APIConnections     *prometheus.GaugeVec
	APIRequestDuration *prometheus.SummaryVec

	PingFailureCount *prometheus.CounterVec

	LogWriteCount *prometheus.CounterVec
	LogReadCount  *prometheus.CounterVec

	TotalRequests         *prometheus.CounterVec
	TotalRequestErrors    *prometheus.CounterVec
	TotalRequestsDuration *prometheus.SummaryVec
}

type DeltaTranslater interface {
	TranslateModel(multiwatcher.EntityInfo) params.EntityInfo
	TranslateApplication(multiwatcher.EntityInfo) params.EntityInfo
	TranslateRemoteApplication(multiwatcher.EntityInfo) params.EntityInfo
	TranslateMachine(multiwatcher.EntityInfo) params.EntityInfo
	TranslateUnit(multiwatcher.EntityInfo) params.EntityInfo
	TranslateCharm(multiwatcher.EntityInfo) params.EntityInfo
	TranslateRelation(multiwatcher.EntityInfo) params.EntityInfo
	TranslateBranch(multiwatcher.EntityInfo) params.EntityInfo
	TranslateAnnotation(multiwatcher.EntityInfo) params.EntityInfo
	TranslateBlock(multiwatcher.EntityInfo) params.EntityInfo
	TranslateAction(multiwatcher.EntityInfo) params.EntityInfo
	TranslateApplicationOffer(multiwatcher.EntityInfo) params.EntityInfo
}

type EntitiesWatcher interface {
	state.StringsWatcher

	// MapChanges maps the received strings to their according tag strings.
	// The EntityFinder interface representing state or a mock has to be
	// upcasted into the needed sub-interface of state for the real mapping.
	MapChanges(in []string) ([]string, error)
}

type ExecEmbeddedCommandFunc func(ctx *cmd.Context, store jujuclient.ClientStore, whitelist []string, cmdPlusArgs string) int

type FailableHandlerFunc func(http.ResponseWriter, *http.Request) error

type Hub interface {
	Publish(string, interface{}) (func(), error)
}

type LogSinkConfig struct {
	// DBLoggerBufferSize is the capacity of the database logger's buffer.
	DBLoggerBufferSize int

	// DBLoggerFlushInterval is the amount of time to allow a log record
	// to sit in the buffer before being flushed to the database.
	DBLoggerFlushInterval time.Duration

	// RateLimitBurst defines the number of log messages that will be let
	// through before we start rate limiting.
	RateLimitBurst int64

	// RateLimitRefill defines the rate at which log messages will be let
	// through once the initial burst amount has been depleted.
	RateLimitRefill time.Duration
}

type Pinger interface {
	Ping()
	Stop() error
}

type RecordLogger interface {
	Log([]corelogger.LogRecord) error
}

type ResourcesBackend interface {
	// OpenResource returns the identified resource and its content.
	OpenResource(applicationID, name string) (resources.Resource, io.ReadCloser, error)

	// GetResource returns the identified resource.
	GetResource(applicationID, name string) (resources.Resource, error)

	// GetPendingResource returns the identified resource.
	GetPendingResource(applicationID, name, pendingID string) (resources.Resource, error)

	// SetResource adds the resource to blob storage and updates the metadata.
	SetResource(applicationID, userID string, res charmresource.Resource, r io.Reader, _ state.IncrementCharmModifiedVersionType) (resources.Resource, error)

	// UpdatePendingResource adds the resource to blob storage and updates the metadata.
	UpdatePendingResource(applicationID, pendingID, userID string, res charmresource.Resource, r io.Reader) (resources.Resource, error)
}

type ResourcesHandler struct {
	StateAuthFunc     func(*http.Request, ...string) (ResourcesBackend, state.PoolHelper, names.Tag, error)
	ChangeAllowedFunc func(*http.Request) error
}

type RestHTTPHandler struct {
	GetHandler FailableHandlerFunc
}

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

type ServerConfig struct {
	Clock     clock.Clock
	PingClock clock.Clock
	Tag       names.Tag
	DataDir   string
	LogDir    string
	Hub       *pubsub.StructuredHub
	Presence  presence.Recorder
	Mux       *apiserverhttp.Mux

	// LocalMacaroonAuthenticator is the request authenticator used for verifying
	// local user macaroons.
	LocalMacaroonAuthenticator macaroon.LocalMacaroonAuthenticator

	// JWTAuthenticator is the request authenticator used for validating jwt
	// tokens when the controller has been bootstrapped with a trusted token
	// provider.
	JWTAuthenticator jwt.Authenticator

	// MultiwatcherFactory is used by the API server to create
	// multiwatchers. The real factory is managed by the multiwatcher
	// worker.
	MultiwatcherFactory multiwatcher.Factory

	// StatePool is the StatePool used for looking up State
	// to pass to facades. StatePool will not be closed by the
	// server; it is the callers responsibility to close it
	// after the apiserver has exited.
	StatePool *state.StatePool

	// Controller is the in-memory representation of the models
	// in the controller. It is kept up to date with an all model
	// watcher and the modelcache worker.
	Controller *cache.Controller

	// UpgradeComplete is a function that reports whether or not
	// the if the agent running the API server has completed
	// running upgrade steps. This is used by the API server to
	// limit logins during upgrades.
	UpgradeComplete func() bool

	// PublicDNSName is reported to the API clients who connect.
	PublicDNSName string

	// AllowModelAccess holds whether users will be allowed to
	// access models that they have access rights to even when
	// they don't have access to the controller.
	AllowModelAccess bool

	// NewObserver is a function which will return an observer. This
	// is used per-connection to instantiate a new observer to be
	// notified of key events during API requests.
	NewObserver observer.ObserverFactory

	// RegisterIntrospectionHandlers is a function that will
	// call a function with (path, http.Handler) tuples. This
	// is to support registering the handlers underneath the
	// "/introspection" prefix.
	RegisterIntrospectionHandlers func(func(string, http.Handler))

	// LogSinkConfig holds parameters to control the API server's
	// logsink endpoint behaviour. If this is nil, the values from
	// DefaultLogSinkConfig() will be used.
	LogSinkConfig *LogSinkConfig

	// SysLogger is a logger that will tee the output from logging
	// to the local syslog.
	SysLogger syslogger.SysLogger

	// GetAuditConfig holds a function that returns the current audit
	// logging config. The function may return updated values, so
	// should be called every time a new login is handled.
	GetAuditConfig func() auditlog.Config

	// LeaseManager gives access to leadership and singular claimers
	// and checkers for use in API facades.
	LeaseManager lease.Manager

	// MetricsCollector defines all the metrics to be collected for the
	// apiserver
	MetricsCollector *Collector

	// ExecEmbeddedCommand is a function which creates an embedded Juju CLI instance.
	ExecEmbeddedCommand ExecEmbeddedCommandFunc

	// CharmhubHTTPClient is the HTTP client used for Charmhub API requests.
	CharmhubHTTPClient facade.HTTPClient

	// DBGetter supplies sql.DB references on request, for named databases.
	DBGetter coredatabase.DBGetter
}

type SharedHub interface {
	Publish(topic string, data interface{}) (func(), error)
	Subscribe(topic string, handler interface{}) (func(), error)
}

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

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

type UnitResourcesHandler struct {
	NewOpener func(*http.Request, ...string) (resources.Opener, state.PoolHelper, error)
}