app

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

type Cache struct {
	// Type is a cache type
	// Available types:
	// * memory
	// * memlru (SizeItems required)
	// * redis
	Type CacheType

	// SizeItems is a maximum items count in memory lru cache
	SizeItems int

	Redis Redis
}

type CacheType string

type Config struct {
	// Debug is a flag to enable debug logging
	Debug bool

	// Cache is optional cache configuration.
	// Cache will not be used if not present (not recommended).
	Cache *Cache

	Github Github

	GoProxy GoProxy

	// PathOverrides contains set of rules for translation module names
	PathOverrides []OverridePath

	Validation Validation

	Server Server

	// HealthServer is a server for liveness and readiness probe handlers.
	// These handlers not added to main server because on graceful shutdown it puts app into false unhealthy status.
	// Server will not be started if section not provided.
	HealthServer *Server

	// Trace is optional tracing/telemetry configuration.
	// Tracing will not be enabled if option not provided.
	Trace *Trace
}

type Github struct {
	// AccessToken is optional github access token
	// It's needed to access private repos or increase rate-limit
	AccessToken MaskedString
}

type GoProxy struct {
	// BaseURL is a goproxy basic url
	// Obviously it must not be athens url which will use this app
	BaseURL MaskedURL
}

type License struct {
	// SPDXID is a spdx license id
	SPDXID string `toml:",omitempty"`

	// Name is a human-readable name
	Name string
}

type MaskedString string

type MaskedURL string

type ModuleMatcher struct {
	// Name is a regular expression for name
	Name string

	// VersionConstraint is a semver version constraint (for syntax see https://github.com/Masterminds/semver/#checking-version-constraints)
	VersionConstraint string `toml:",omitempty"`
}

type NotificationType string

type OverridePath struct {
	// Match is a regular expression to match module name
	Match string

	// Replace is a replacement string for module name.
	// Regexp capturing group placeholders (i.e $1, $2) may be used here.
	Replace string
}

type Redis struct {
	// Addrs is a slice of connection addresses
	// If more than one provided cluster client will be used
	Addrs []string

	// TTL is optional ttl for keys. Keys will not expire when TTL is not set.
	TTL time.Duration

	// PoolSize is a connection pool size. Default value is 10
	PoolSize int

	// DB allows to select db number
	DB int

	// Password is an optional password
	Password MaskedString

	// ConnectTimeout is an optional connect timeout
	ConnectTimeout time.Duration

	// ReadTimeout is an optional timeout to receive data
	ReadTimeout time.Duration

	// WriteTimeout is an optional timeout to send data
	WriteTimeout time.Duration
}

type RuleSet struct {
	// WhitelistedModules always passes validation
	WhitelistedModules []ModuleMatcher

	// BlacklistedModules always fails validation
	BlacklistedModules []ModuleMatcher

	// AllowedLicenses contains set of allowed licenses
	// Note that if it's not empty only these licenses will be allowed.
	AllowedLicenses []License

	// DeniedLicenses contains set of denied licenses
	DeniedLicenses []License
}

type Server struct {
	// ListenAddr is a listen address (i.e. ':8080')
	ListenAddr string
	// EnablePprof adds pprof handlers to server at /pprof
	EnablePprof bool
}

type Trace struct {
	// CollectorAddress is a traces collector address
	CollectorAddress string

	// TracerType is a trace collector type. Available types:
	// * zipkin
	// * jaeger
	TracerType TracerType

	// SampleProbability samples a given fraction of traces. Fractions >= 1 or <= 0 will
	// always sample. If the parent span is sampled, then it's child spans will
	// automatically be sampled
	SampleProbability float64
}

type TracerType string

type UnknownLicenseAction string

type Validation struct {
	// UnknownLicenseAction specifies what to do if unknown license met.
	// Currently available:
	// * allow - simply allow such module
	// * warn - allows such module but notifies
	// * deny - fails module validation
	UnknownLicenseAction UnknownLicenseAction

	// ConfidenceThreshold is a lower bound for license matching confidence when it's done by go-license-detector
	ConfidenceThreshold float64

	RuleSet RuleSet

	// NotificationType is an unknown license notification type
	NotificationType NotificationType

	Webhook *WebhookNotification
}

type WebhookNotification struct {
	// Address is a target webhook addres (full url)
	Address MaskedURL
	// Method is optional http method for webhook request. Default is POST.
	Method string
	// Headers contains additional http headers for webhook request.
	Headers map[string]string
	// BodyTemplate is optional request body template string in 'text/template' syntax.
	// Execution context defined in 'pkg/validation.WebhookTemplateContext'.
	// Also helper function 'toJSON' is available that converts input argument to json string.
	BodyTemplate string
}