model

type ArtifactInfo struct {
	Type        PailType        `bson:"type"`
	Bucket      string          `bson:"bucket"`
	Prefix      string          `bson:"prefix"`
	Path        string          `bson:"path"`
	Format      FileDataFormat  `bson:"format"`
	Compression FileCompression `bson:"compression"`
	Schema      FileSchema      `bson:"schema"`
	Tags        []string        `bson:"tags,omitempty"`
	CreatedAt   time.Time       `bson:"created_at"`
}

type BatchJobController struct {
	ID         string        `bson:"_id"`
	Collection string        `bson:"collection,omitempty"`
	BatchSize  int           `bson:"batch_size"`
	Iterations int           `bson:"iterations,omitempty"`
	Timeout    time.Duration `bson:"timeout,omitempty"`
	Version    int           `bson:"version"`
}

type BucketConfig struct {
	AWSKey                string   `bson:"aws_key" json:"aws_key" yaml:"aws_key"`
	AWSSecret             string   `bson:"aws_secret" json:"aws_secret" yaml:"aws_secret"`
	BuildLogsBucket       string   `bson:"build_logs_bucket" json:"build_logs_bucket" yaml:"build_logs_bucket"`
	TestResultsBucket     string   `bson:"test_results_bucket" json:"test_results_bucket" yaml:"test_results_bucket"`
	TestResultsBucketType PailType `bson:"test_results_bucket_type" json:"test_results_bucket_type" yaml:"test_results_bucket_type"`

	PrestoRoleARN           string `bson:"presto_role_arn" json:"presto_role_arn" yaml:"presto_role_arn"`
	PrestoBucket            string `bson:"presto_bucket" json:"presto_bucket" yaml:"presto_bucket"`
	PrestoTestResultsPrefix string `bson:"presto_test_results_prefix" json:"presto_test_results_prefix" yaml:"presto_test_results_prefix"`
}

type CAConfig struct {
	CertDepot         certdepot.BootstrapDepotConfig `bson:"certdepot" json:"certdepot" yaml:"certdepot"`
	SSLExpireAfter    time.Duration                  `bson:"ssl_expire" json:"ssl_expire" yaml:"ssl_expire"`
	SSLRenewalBefore  time.Duration                  `bson:"ssl_renewal" json:"ssl_renewal" yaml:"ssl_renewal"`
	ServerCertVersion int                            `bson:"server_cert_version"`
}

type CedarConfig struct {
	ID             string                    `bson:"_id" json:"id" yaml:"id"`
	URL            string                    `bson:"url" json:"url" yaml:"url"`
	Evergreen      EvergreenConfig           `bson:"evergreen" json:"evergreen" yaml:"evergreen"`
	Splunk         send.SplunkConnectionInfo `bson:"splunk" json:"splunk" yaml:"splunk"`
	LoggerConfig   LoggerParams              `bson:"logger_config" json:"logger_config" yaml:"logger_config"`
	Slack          SlackConfig               `bson:"slack" json:"slack" yaml:"slack"`
	LDAP           LDAPConfig                `bson:"ldap" json:"ldap" yaml:"ldap"`
	ServiceAuth    ServiceAuthConfig         `bson:"service_auth" json:"service_auth" yaml:"service_auth"`
	NaiveAuth      NaiveAuthConfig           `bson:"naive_auth" json:"naive_auth" yaml:"naive_auth"`
	CA             CAConfig                  `bson:"ca" json:"ca" yaml:"ca"`
	Bucket         BucketConfig              `bson:"bucket" json:"bucket" yaml:"bucket"`
	Flags          OperationalFlags          `bson:"flags" json:"flags" yaml:"flags"`
	Service        ServiceConfig             `bson:"service" json:"service" yaml:"service"`
	ChangeDetector ChangeDetectorConfig      `bson:"change_detector" json:"change_detector" yaml:"change_detector"`
	// contains filtered or unexported fields
}

type ChangeDetectorConfig struct {
	Implementation string `bson:"implementation" json:"implementation" yaml:"implementation"`
	URI            string `bson:"uri" json:"uri" yaml:"uri"`
	User           string `bson:"user" json:"user" yaml:"user"`
	Token          string `bson:"token" json:"token" yaml:"token"`
}

type Event struct {
	ID           string      `bson:"_id" json:"id"`
	Component    string      `bson:"com" json:"component"`
	Message      string      `bson:"m" json:"message"`
	Payload      interface{} `bson:"data" json:"payload"`
	MessageType  string      `bson:"mtype" json:"type"`
	Timestamp    time.Time   `bson:"ts" json:"time"`
	Level        string      `bson:"l" json:"level"`
	Acknowledged bool        `bson:"ack" json:"acknowledged"`
	// contains filtered or unexported fields
}

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

type EvergreenConfig struct {
	URL               string `bson:"url" json:"url" yaml:"url"`
	AuthTokenCookie   string `bson:"auth_token_cookie" json:"auth_token_cookie" yaml:"auth_token_cookie"`
	HeaderKeyName     string `bson:"header_key_name" json:"header_key_name" yaml:"header_key_name"`
	HeaderUserName    string `bson:"header_user_name" json:"header_user_name" yaml:"header_user_name"`
	Domain            string `bson:"domain" json:"domain" yaml:"domain"`
	ServiceUserName   string `bson:"service_user_name" json:"service_user_name" yaml:"service_user_name"`
	ServiceUserAPIKey string `bson:"service_user_api_key" json:"service_user_api_key" yaml:"service_user_api_key"`
}

type FileCompression string

type FileDataFormat string

type FileSchema string

type Iterator interface {
	// Next returns true if the iterator has not yet been exhausted or
	// closed, false otherwise.
	Next(context.Context) bool
	// Exhausted returns true if the iterator has not yet been exhausted,
	// regardless if it has been closed or not.
	Exhausted() bool
	// Err returns any errors that are captured by the iterator.
	Err() error
	// Close closes the iterator. This function should be called once the
	// iterator is no longer needed.
	Close() error
}

type LDAPConfig struct {
	URL          string `bson:"url" json:"url" yaml:"url"`
	Port         string `bson:"port" json:"port" yaml:"port"`
	UserPath     string `bson:"path" json:"path" yaml:"path"`
	ServicePath  string `bson:"service_path" json:"service_path" yaml:"service_path"`
	UserGroup    string `bson:"user_group" json:"user_group" yaml:"user_group"`
	ServiceGroup string `bson:"service_group" json:"service_group" yaml:"service_group"`
}

type Log struct {
	ID          string          `bson:"_id,omitempty"`
	Info        LogInfo         `bson:"info,omitempty"`
	CreatedAt   time.Time       `bson:"created_at"`
	CompletedAt time.Time       `bson:"completed_at"`
	Artifact    LogArtifactInfo `bson:"artifact"`
	// contains filtered or unexported fields
}

type LogArtifactInfo struct {
	Type    PailType `bson:"type"`
	Prefix  string   `bson:"prefix"`
	Version int      `bson:"version"`
	// This field is part of the version 0 LogArtifactInfo model, we are
	// keeping it for backwards compatibility.
	Chunks []LogChunkInfo `bson:"chunks,omitempty"`
}

type LogChunkInfo struct {
	Key      string    `bson:"key"`
	NumLines int       `bson:"num_lines"`
	Start    time.Time `bson:"start"`
	End      time.Time `bson:"end"`
}

type LogFindOptions struct {
	TimeRange       TimeRange
	Info            LogInfo
	Group           string
	EmptyTestName   bool
	LatestExecution bool
	Limit           int64
}

type LogFormat string

type LogInfo struct {
	Project     string            `bson:"project,omitempty"`
	Version     string            `bson:"version,omitempty"`
	Variant     string            `bson:"variant,omitempty"`
	TaskName    string            `bson:"task_name,omitempty"`
	TaskID      string            `bson:"task_id,omitempty"`
	Execution   int               `bson:"execution"`
	TestName    string            `bson:"test_name,omitempty"`
	Trial       int               `bson:"trial"`
	ProcessName string            `bson:"proc_name,omitempty"`
	Format      LogFormat         `bson:"format,omitempty"`
	Tags        []string          `bson:"tags,omitempty"`
	Arguments   map[string]string `bson:"args,omitempty"`
	ExitCode    int               `bson:"exit_code, omitempty"`
	Mainline    bool              `bson:"mainline"`
	Schema      int               `bson:"schema,omitempty"`
}

type LogIterator interface {
	Iterator
	// Item returns the current LogLine item held by the iterator.
	Item() LogLine
	// Reverse returns a reversed copy of the iterator.
	Reverse() LogIterator
	// IsReversed returns true if the iterator is in reverse order and
	// false otherwise.
	IsReversed() bool
}

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

type LogIteratorReaderOptions struct {
	// Limit limits the number of lines read from the log. If equal to 0,
	// lines will be read until the iterator is exhausted. If TailN is
	// greater than 0, Limit will be ignored.
	Limit int
	// TailN is the number of lines to read from the tail of the log. If
	// equal to 0, the reader returned will read log lines in normal order.
	TailN int
	// PrintTime, when true, prints the timestamp of each log line along
	// with the line in the following format:
	//		[2006/01/02 15:04:05.000] This is a log line.
	PrintTime bool
	// PrintPriority, when true, prints the priority of each log line along
	// with the line in the following format:
	//		[P: 30] This is a log line.
	// If PrintTime is also set to true, priority will be printed first:
	//		[P:100] [2006/01/02 15:04:05.000] This is a log line.
	PrintPriority bool
	// SoftSizeLimit assists with pagination of long logs. When set the
	// reader will attempt to read as close to the limit as possible while
	// also reading every line for each timestamp reached. If TailN is set,
	// this will be ignored.
	SoftSizeLimit int
}

type LogLine struct {
	Priority  level.Priority
	Timestamp time.Time
	Data      string
}

type LogMetrics struct {
	NumberLines       int            `bson:"lines"`
	UniqueLetters     int            `bson:"letters"`
	LetterFrequencies map[string]int `bson:"frequencies"`
}

type LogRecord struct {
	LogID       string `bson:"_id"`
	URL         string `bson:"url"`
	LastSegment int    `bson:"seg"`
	Bucket      string `bson:"bucket"`
	KeyName     string `bson:"key"`
	Metadata    `bson:"metadata"`
	// contains filtered or unexported fields
}

type LogSegment struct {
	// common log information
	ID      string `bson:"_id"`
	LogID   string `bson:"log_id"`
	URL     string `bson:"url"`
	Segment int    `bson:"seg"`
	Bucket  string `bson:"bucket"`
	KeyName string `bson:"key"`

	// parsed out information
	Metrics LogMetrics `bson:"metrics"`

	Metadata `bson:"metadata"`
	// contains filtered or unexported fields
}

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

type LoggerParams struct {
	BufferCount          int           `bson:"buffer_count" json:"buffer_count" yaml:"buffer_count"`
	BufferDuration       time.Duration `bson:"buffer_duration" json:"buffer_duration" yaml:"buffer_duration"`
	IncomingBufferFactor int           `bson:"incoming_buffer_factor" json:"incoming_buffer_factor" yaml:"incoming_buffer_factor"`
	UseAsync             bool          `bson:"use_async" json:"use_async" yaml:"use_async"`
}

type LoginCache struct {
	Token string    `bson:"token"`
	TTL   time.Time `bson:"ttl"`
}

type Logs struct {
	Logs []Log `bson:"results"`
	// contains filtered or unexported fields
}

type Metadata struct {
	ModificationCount int            `bson:"nmod"`
	Version           int            `bson:"sver"`
	Units             map[string]int `bson:"units"`
}

type MetricType string

type MigrationStats struct {
	MigratorID  string     `bson:"migrator_id"`
	StartedAt   *time.Time `bson:"started_at"`
	CompletedAt *time.Time `bson:"completed_at"`
	Version     int        `bson:"version"`
}

type NaiveAuthConfig struct {
	AppAuth bool              `bson:"app_auth" json:"app_auth" yaml:"app_auth"`
	Users   []NaiveUserConfig `bson:"users" json:"users" yaml:"users"`
}

type NaiveUserConfig struct {
	ID           string   `bson:"_id" json:"id" yaml:"id"`
	Name         string   `bson:"name" json:"name" yaml:"name"`
	EmailAddress string   `bson:"email" json:"email" yaml:"email"`
	Password     string   `bson:"password" json:"password" yaml:"password"`
	Key          string   `bson:"key" json:"key" yaml:"key"`
	AccessRoles  []string `bson:"roles" json:"roles" yaml:"roles"`
	Invalid      bool     `bson:"invalid" json:"invalid" yaml:"invalid"`
}

type OperationalFlags struct {
	DisableInternalMetricsReporting bool `bson:"disable_internal_metrics_reporting" json:"disable_internal_metrics_reporting" yaml:"disable_internal_metrics_reporting"`
	DisableSignalProcessing         bool `bson:"disable_signal_processing" json:"disable_signal_processing" yaml:"disable_signal_processing"`
	// contains filtered or unexported fields
}

type PailType string

type ParquetTestResult struct {
	TestName        string       `parquet:"name=test_name"`
	DisplayTestName *string      `parquet:"name=display_test_name"`
	GroupID         *string      `parquet:"name=group_id"`
	Trial           int32        `parquet:"name=trial"`
	Status          string       `parquet:"name=status"`
	LogInfo         *TestLogInfo `parquet:"name=log_info"`
	TaskCreateTime  time.Time    `parquet:"name=task_create_time, timeunit=MILLIS"`
	TestStartTime   time.Time    `parquet:"name=test_start_time, timeunit=MILLIS"`
	TestEndTime     time.Time    `parquet:"name=test_end_time, timeunit=MILLIS"`

	// Legacy test log fields.
	LogTestName *string `parquet:"name=log_test_name"`
	LogURL      *string `parquet:"name=log_url"`
	RawLogURL   *string `parquet:"name=raw_log_url"`
	LineNum     *int32  `parquet:"name=line_num"`
}

type ParquetTestResults struct {
	Version         string              `parquet:"name=version"`
	Variant         string              `parquet:"name=variant"`
	TaskName        string              `parquet:"name=task_name"`
	DisplayTaskName *string             `parquet:"name=display_task_name"`
	TaskID          string              `parquet:"name=task_id"`
	DisplayTaskID   *string             `parquet:"name=display_task_id"`
	Execution       int32               `parquet:"name=execution"`
	RequestType     string              `parquet:"name=request_type"`
	CreatedAt       time.Time           `parquet:"name=created_at, timeunit=MILLIS"`
	Results         []ParquetTestResult `parquet:"name=results"`
}

type PerfAnalysis struct {
	ProcessedAt time.Time `bson:"processed_at" json:"processed_at" yaml:"processed_at"`
}

type PerfFindOptions struct {
	Interval    TimeRange
	Info        PerformanceResultInfo
	MaxDepth    int
	GraphLookup bool
	Limit       int
	Skip        int
	Sort        []string
}

type PerfRollupValue struct {
	Name          string      `bson:"name"`
	Value         interface{} `bson:"val"`
	Version       int         `bson:"version"`
	MetricType    MetricType  `bson:"type"`
	UserSubmitted bool        `bson:"user"`
}

type PerfRollups struct {
	Stats       []PerfRollupValue `bson:"stats"`
	ProcessedAt time.Time         `bson:"processed_at"`
	// contains filtered or unexported fields
}

type PerformanceArguments map[string]int32

type PerformanceResult struct {
	ID          string                `bson:"_id,omitempty"`
	Info        PerformanceResultInfo `bson:"info,omitempty"`
	CreatedAt   time.Time             `bson:"created_at"`
	CompletedAt time.Time             `bson:"completed_at"`
	Version     int                   `bson:"version,omitempty"`

	// The source timeseries data is stored in a remote location,
	// we'll probably need to store an identifier so we know which
	// service to use to access that data. We'd then summarize
	// that data and store it in the document.
	//
	// The structure has a both a schema to describe the layout
	// the data (e.g. raw, results,) format (e.g. bson/ftdc/json),
	// and tags to describe the source (e.g. user submitted,
	// generated.)
	Artifacts            []ArtifactInfo `bson:"artifacts"`
	FailedRollupAttempts int            `bson:"failed_rollup_attempts"`

	Rollups  PerfRollups  `bson:"rollups"`
	Analysis PerfAnalysis `bson:"analysis"`
	// contains filtered or unexported fields
}

type PerformanceResultInfo struct {
	Project   string               `bson:"project,omitempty"`
	Version   string               `bson:"version,omitempty"`
	Variant   string               `bson:"variant,omitempty"`
	Order     int                  `bson:"order,omitempty"`
	TaskName  string               `bson:"task_name,omitempty"`
	TaskID    string               `bson:"task_id,omitempty"`
	Execution int                  `bson:"execution"`
	TestName  string               `bson:"test_name,omitempty"`
	Trial     int                  `bson:"trial"`
	Parent    string               `bson:"parent,omitempty"`
	Tags      []string             `bson:"tags,omitempty"`
	Arguments PerformanceArguments `bson:"args,omitempty"`
	Mainline  bool                 `bson:"mainline"`
	Schema    int                  `bson:"schema,omitempty"`
}

type PerformanceResultSeriesID struct {
	Project     string               `bson:"project"`
	Variant     string               `bson:"variant"`
	Task        string               `bson:"task"`
	Test        string               `bson:"test"`
	Measurement string               `bson:"measurement"`
	Arguments   PerformanceArguments `bson:"args"`
}

type PerformanceResults struct {
	Results []PerformanceResult `bson:"results"`
	// contains filtered or unexported fields
}

type ServiceAuthConfig struct {
	Enabled bool `bson:"enabled" json:"enabled" yaml:"enabled"`
}

type ServiceConfig struct {
	AppServers  []string `bson:"app_servers" json:"app_servers" yaml:"app_servers"`
	CORSOrigins []string `bson:"cors_origins" json:"cors_origins" yaml:"cors_origins"`
}

type SlackConfig struct {
	Options *send.SlackOptions `bson:"options" json:"options" yaml:"options"`
	Token   string             `bson:"token" json:"token" yaml:"token"`
	Level   string             `bson:"level" json:"level" yaml:"level"`
}

type SystemIndexes struct {
	Keys       bson.D
	Options    bson.D
	Collection string
}

type SystemInformationRecord struct {
	ID        string             `bson:"_id" json:"id"`
	Timestamp time.Time          `bson:"ts" json:"time"`
	Data      message.SystemInfo `bson:"sysinfo" json:"sysinfo"`
	Hostname  string             `bson:"hn" json:"hostname"`
	// contains filtered or unexported fields
}

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

type TestLogInfo struct {
	LogName       string    `parquet:"name=log_name" bson:"log_name"`
	LogsToMerge   []*string `parquet:"name=logs_to_merge" bson:"logs_to_merge,omitempty"`
	LineNum       int32     `parquet:"name=line_num" bson:"line_num"`
	RenderingType *string   `parquet:"name=rendering_type" bson:"rendering_type,omitempty"`
	Version       int32     `parquet:"name=version" bson:"version"`
}

type TestResult struct {
	TaskID          string       `bson:"task_id"`
	Execution       int          `bson:"execution"`
	TestName        string       `bson:"test_name"`
	DisplayTestName string       `bson:"display_test_name,omitempty"`
	GroupID         string       `bson:"group_id,omitempty"`
	Trial           int          `bson:"trial"`
	Status          string       `bson:"status"`
	BaseStatus      string       `bson:"-"`
	LogInfo         *TestLogInfo `bson:"log_info,omitempty"`
	TaskCreateTime  time.Time    `bson:"task_create_time"`
	TestStartTime   time.Time    `bson:"test_start_time"`
	TestEndTime     time.Time    `bson:"test_end_time"`

	// Legacy test log fields.
	LogTestName string `bson:"log_test_name,omitempty"`
	LogURL      string `bson:"log_url,omitempty"`
	RawLogURL   string `bson:"raw_log_url,omitempty"`
	LineNum     int    `bson:"line_num"`
}

type TestResults struct {
	ID          string                  `bson:"_id,omitempty"`
	Info        TestResultsInfo         `bson:"info"`
	CreatedAt   time.Time               `bson:"created_at"`
	CompletedAt time.Time               `bson:"completed_at"`
	Artifact    TestResultsArtifactInfo `bson:"artifact"`
	Stats       TestResultsStats        `bson:"stats"`
	// FailedTestsSample is the first X failing tests of the test results.
	// This is an optimization for Evergreen's UI features that display a
	// limited number of failing tests for a task.
	FailedTestsSample []string `bson:"failed_tests_sample"`
	// contains filtered or unexported fields
}

type TestResultsArtifactInfo struct {
	Type    PailType `bson:"type"`
	Prefix  string   `bson:"prefix"`
	Version int      `bson:"version"`
}

type TestResultsFilterAndSortOptions struct {
	TestName            string
	ExcludeDisplayNames bool
	Statuses            []string
	GroupID             string
	Sort                []TestResultsSortBy
	Limit               int
	Page                int
	BaseTasks           []TestResultsTaskOptions
	// contains filtered or unexported fields
}

type TestResultsInfo struct {
	Project         string `bson:"project"`
	Version         string `bson:"version"`
	Variant         string `bson:"variant"`
	TaskName        string `bson:"task_name"`
	DisplayTaskName string `bson:"display_task_name,omitempty"`
	TaskID          string `bson:"task_id"`
	DisplayTaskID   string `bson:"display_task_id,omitempty"`
	Execution       int    `bson:"execution"`
	RequestType     string `bson:"request_type"`
	Mainline        bool   `bson:"mainline"`
	Schema          int    `bson:"schema"`
}

type TestResultsIterator interface {
	Iterator
	// Item returns the current TestResult item held by the iterator.
	Item() TestResult
}

type TestResultsSample struct {
	TaskID                  string
	Execution               int
	MatchingFailedTestNames []string
	TotalFailedTestNames    int
}

type TestResultsSortBy struct {
	Key      string
	OrderDSC bool
}

type TestResultsStats struct {
	TotalCount    int  `bson:"total_count"`
	FailedCount   int  `bson:"failed_count"`
	FilteredCount *int `bson:"-"`
}

type TestResultsTaskOptions struct {
	TaskID    string
	Execution int
}

type TimeRange struct {
	StartAt time.Time `bson:"start" json:"start" yaml:"start"`
	EndAt   time.Time `bson:"end" json:"end" yaml:"end"`
}

type UnanalyzedPerformanceSeries struct {
	Project      string               `bson:"project"`
	Variant      string               `bson:"variant"`
	Task         string               `bson:"task"`
	Test         string               `bson:"test"`
	Measurements []string             `bson:"measurements"`
	Arguments    PerformanceArguments `bson:"args"`
}

type User struct {
	ID           string     `bson:"_id"`
	Display      string     `bson:"display_name"`
	EmailAddress string     `bson:"email"`
	CreatedAt    time.Time  `bson:"created_at"`
	APIKey       string     `bson:"apikey"`
	SystemRoles  []string   `bson:"roles,omitempty"`
	LoginCache   LoginCache `bson:"login_cache,omitempty"`
	// contains filtered or unexported fields
}