model

package
v0.0.0-...-1d50e38 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 30, 2017 License: Apache-2.0 Imports: 35 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// if we have no data on a given task, default to 10 minutes so we
	// have some new hosts spawned
	DefaultTaskDuration = time.Duration(10) * time.Minute

	// for the UI, if we have no data on a given task, we want to default to
	// 0 time
	UnknownTaskDuration = time.Duration(0)

	// indicates the window of completed tasks we want to use in computing
	// average task duration. By default we use tasks that have
	// completed within the last 7 days
	TaskCompletionEstimateWindow = time.Duration(24*7) * time.Hour
)
View Source 
const (
	AllDependencies = "*"
	AllVariants     = "*"
	AllStatuses     = "*"
)
View Source 
const (
	TestCommandType   = "test"
	SystemCommandType = "system"
)
View Source 
const (
	SelectAll             = "*"
	InvalidCriterionRunes = "!."
)
View Source 
const (
	PushlogCollection = "pushes"
	PushLogSuccess    = "success"
	PushLogFailed     = "failed"
)
View Source 
const (
	TaskTimeout       = "timeout"
	TaskSystemFailure = "sysfail"
)
View Source 
const (
	TaskLogDB         = "logs"
	TaskLogCollection = "task_logg"
	MessagesPerLog    = 10
)
View Source 
const (
	SystemLogPrefix = "S"
	AgentLogPrefix  = "E"
	TaskLogPrefix   = "T"

	LogErrorPrefix = "E"
	LogWarnPrefix  = "W"
	LogDebugPrefix = "D"
	LogInfoPrefix  = "I"
)

for the different types of remote logging

View Source 
const (
	// DefaultCommandType is a system configuration option that is used to
	// differentiate between setup related commands and actual testing commands.
	DefaultCommandType = TestCommandType
)
View Source 
const (
	GithubRepoType = "github"
)
View Source 
const (
	NotifyHistoryCollection = "notify_history"
)
View Source 
const (
	NotifyTimesCollection = "notify_times"
)
View Source 
const (
	ProjectRefCollection = "project_ref"
)
View Source 
const (
	ProjectVarsCollection = "project_vars"
)
View Source 
const (
	RepositoriesCollection = "repo_revisions"
)
View Source 
const (
	RuntimesCollection = "process_runtimes"
)
View Source 
const (
	StaleVersionCutoff = 100
)

Maximum number of versions to consider for last_green, more than 100 revisions back considered "stale"

View Source 
const (
	TaskQueuesCollection = "task_queues"
)
View Source 
const TestLogCollection = "test_logs"

Variables

View Source 
var (
	StuckHostKey            = bsonutil.MustHaveTag(StuckHostInconsistency{}, "Host")
	StuckHostRunningTaskKey = bsonutil.MustHaveTag(StuckHostInconsistency{}, "RunningTask")
	StuckHostTaskStatusKey  = bsonutil.MustHaveTag(StuckHostInconsistency{}, "TaskStatus")
	HostTaskKey             = "task"
)
View Source 
var (
	// bson fields for the notification history struct
	NHIdKey     = bsonutil.MustHaveTag(NotificationHistory{}, "Id")
	NHPrevIdKey = bsonutil.MustHaveTag(NotificationHistory{},
		"PrevNotificationId")
	NHCurrIdKey = bsonutil.MustHaveTag(NotificationHistory{},
		"CurrNotificationId")
	NHNameKey = bsonutil.MustHaveTag(NotificationHistory{},
		"NotificationName")
	NHTypeKey = bsonutil.MustHaveTag(NotificationHistory{},
		"NotificationType")
	NHTimeKey = bsonutil.MustHaveTag(NotificationHistory{},
		"NotificationTime")
	NHProjectKey = bsonutil.MustHaveTag(NotificationHistory{},
		"NotificationProject")
	NHRequesterKey = bsonutil.MustHaveTag(NotificationHistory{},
		"NotificationRequester")
)
View Source 
var (
	PntProjectNameKey = bsonutil.MustHaveTag(ProjectNotificationTime{},
		"ProjectName")
	PntLastEventTime = bsonutil.MustHaveTag(ProjectNotificationTime{},
		"LastNotificationEventTime")
)
View Source 
var (
	ProcRuntimeIdKey         = bsonutil.MustHaveTag(ProcessRuntime{}, "Id")
	ProcRuntimeFinishedAtKey = bsonutil.MustHaveTag(ProcessRuntime{},
		"FinishedAt")
	ProcRuntimeRuntimeKey = bsonutil.MustHaveTag(ProcessRuntime{}, "Runtime")
)
View Source 
var (
	// bson fields for the project struct
	ProjectIdentifierKey    = bsonutil.MustHaveTag(Project{}, "Identifier")
	ProjectPreKey           = bsonutil.MustHaveTag(Project{}, "Pre")
	ProjectPostKey          = bsonutil.MustHaveTag(Project{}, "Post")
	ProjectModulesKey       = bsonutil.MustHaveTag(Project{}, "Modules")
	ProjectBuildVariantsKey = bsonutil.MustHaveTag(Project{}, "BuildVariants")
	ProjectFunctionsKey     = bsonutil.MustHaveTag(Project{}, "Functions")
	ProjectStepbackKey      = bsonutil.MustHaveTag(Project{}, "Stepback")
	ProjectTasksKey         = bsonutil.MustHaveTag(Project{}, "Tasks")
)
View Source 
var (
	// bson fields for the ProjectRef struct
	ProjectRefOwnerKey              = bsonutil.MustHaveTag(ProjectRef{}, "Owner")
	ProjectRefRepoKey               = bsonutil.MustHaveTag(ProjectRef{}, "Repo")
	ProjectRefBranchKey             = bsonutil.MustHaveTag(ProjectRef{}, "Branch")
	ProjectRefRepoKindKey           = bsonutil.MustHaveTag(ProjectRef{}, "RepoKind")
	ProjectRefEnabledKey            = bsonutil.MustHaveTag(ProjectRef{}, "Enabled")
	ProjectRefPrivateKey            = bsonutil.MustHaveTag(ProjectRef{}, "Private")
	ProjectRefBatchTimeKey          = bsonutil.MustHaveTag(ProjectRef{}, "BatchTime")
	ProjectRefIdentifierKey         = bsonutil.MustHaveTag(ProjectRef{}, "Identifier")
	ProjectRefDisplayNameKey        = bsonutil.MustHaveTag(ProjectRef{}, "DisplayName")
	ProjectRefDeactivatePreviousKey = bsonutil.MustHaveTag(ProjectRef{}, "DeactivatePrevious")
	ProjectRefRemotePathKey         = bsonutil.MustHaveTag(ProjectRef{}, "RemotePath")
	ProjectRefTrackedKey            = bsonutil.MustHaveTag(ProjectRef{}, "Tracked")
	ProjectRefLocalConfig           = bsonutil.MustHaveTag(ProjectRef{}, "LocalConfig")
	ProjectRefAlertsKey             = bsonutil.MustHaveTag(ProjectRef{}, "Alerts")
	ProjectRefRepotrackerError      = bsonutil.MustHaveTag(ProjectRef{}, "RepotrackerError")
	ProjectRefAdminsKey             = bsonutil.MustHaveTag(ProjectRef{}, "Admins")
)
View Source 
var (
	ProjectVarIdKey   = bsonutil.MustHaveTag(ProjectVars{}, "Id")
	ProjectVarsMapKey = bsonutil.MustHaveTag(ProjectVars{}, "Vars")
	PrivateVarsMapKey = bsonutil.MustHaveTag(ProjectVars{}, "PrivateVars")
)
View Source 
var (
	// bson fields for the push log struct
	PushLogIdKey         = bsonutil.MustHaveTag(PushLog{}, "Id")
	PushLogLocationKey   = bsonutil.MustHaveTag(PushLog{}, "Location")
	PushLogTaskIdKey     = bsonutil.MustHaveTag(PushLog{}, "TaskId")
	PushLogCreateTimeKey = bsonutil.MustHaveTag(PushLog{}, "CreateTime")
	PushLogRevisionKey   = bsonutil.MustHaveTag(PushLog{}, "Revision")
	PushLogStatusKey     = bsonutil.MustHaveTag(PushLog{}, "Status")
	PushLogRonKey        = bsonutil.MustHaveTag(PushLog{}, "RevisionOrderNumber")
)
View Source 
var (
	// BSON fields for the Repository struct
	RepoProjectKey = bsonutil.MustHaveTag(Repository{},
		"Project")
	RepoLastRevisionKey = bsonutil.MustHaveTag(Repository{},
		"LastRevision")
	RepositoryOrderNumberKey = bsonutil.MustHaveTag(Repository{},
		"RevisionOrderNumber")
)
View Source 
var (
	TestFileKey        = bsonutil.MustHaveTag(TestHistoryResult{}, "TestFile")
	TaskNameKey        = bsonutil.MustHaveTag(TestHistoryResult{}, "TaskName")
	TaskStatusKey      = bsonutil.MustHaveTag(TestHistoryResult{}, "TaskStatus")
	TestStatusKey      = bsonutil.MustHaveTag(TestHistoryResult{}, "TestStatus")
	RevisionKey        = bsonutil.MustHaveTag(TestHistoryResult{}, "Revision")
	ProjectKey         = bsonutil.MustHaveTag(TestHistoryResult{}, "Project")
	TaskIdKey          = bsonutil.MustHaveTag(TestHistoryResult{}, "TaskId")
	BuildVariantKey    = bsonutil.MustHaveTag(TestHistoryResult{}, "BuildVariant")
	EndTimeKey         = bsonutil.MustHaveTag(TestHistoryResult{}, "EndTime")
	StartTimeKey       = bsonutil.MustHaveTag(TestHistoryResult{}, "StartTime")
	ExecutionKey       = bsonutil.MustHaveTag(TestHistoryResult{}, "Execution")
	OldTaskIdKey       = bsonutil.MustHaveTag(TestHistoryResult{}, "OldTaskId")
	UrlKey             = bsonutil.MustHaveTag(TestHistoryResult{}, "Url")
	UrlRawKey          = bsonutil.MustHaveTag(TestHistoryResult{}, "UrlRaw")
	TaskTimedOutKey    = bsonutil.MustHaveTag(TestHistoryResult{}, "TaskTimedOut")
	TaskDetailsTypeKey = bsonutil.MustHaveTag(TestHistoryResult{}, "TaskDetailsType")
	LogIdKey           = bsonutil.MustHaveTag(TestHistoryResult{}, "LogId")
)

TestHistoryResult bson tags

View Source 
var (
	// bson fields for the task log struct
	TaskLogIdKey           = bsonutil.MustHaveTag(TaskLog{}, "Id")
	TaskLogTaskIdKey       = bsonutil.MustHaveTag(TaskLog{}, "TaskId")
	TaskLogExecutionKey    = bsonutil.MustHaveTag(TaskLog{}, "Execution")
	TaskLogTimestampKey    = bsonutil.MustHaveTag(TaskLog{}, "Timestamp")
	TaskLogMessageCountKey = bsonutil.MustHaveTag(TaskLog{}, "MessageCount")
	TaskLogMessagesKey     = bsonutil.MustHaveTag(TaskLog{}, "Messages")

	// bson fields for the log message struct
	LogMessageTypeKey      = bsonutil.MustHaveTag(LogMessage{}, "Type")
	LogMessageSeverityKey  = bsonutil.MustHaveTag(LogMessage{}, "Severity")
	LogMessageMessageKey   = bsonutil.MustHaveTag(LogMessage{}, "Message")
	LogMessageTimestampKey = bsonutil.MustHaveTag(LogMessage{}, "Timestamp")
)
View Source 
var (
	// bson fields for the task queue struct
	TaskQueueIdKey     = bsonutil.MustHaveTag(TaskQueue{}, "Id")
	TaskQueueDistroKey = bsonutil.MustHaveTag(TaskQueue{}, "Distro")
	TaskQueueQueueKey  = bsonutil.MustHaveTag(TaskQueue{}, "Queue")

	// bson fields for the individual task queue items
	TaskQueueItemIdKey          = bsonutil.MustHaveTag(TaskQueueItem{}, "Id")
	TaskQueueItemDisplayNameKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"DisplayName")
	TaskQueueItemBuildVariantKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"BuildVariant")
	TaskQueueItemConKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"RevisionOrderNumber")
	TaskQueueItemRequesterKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"Requester")
	TaskQueueItemRevisionKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"Revision")
	TaskQueueItemProjectKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"Project")
	TaskQueueItemExpDurationKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"ExpectedDuration")
	TaskQueuePriorityKey = bsonutil.MustHaveTag(TaskQueueItem{},
		"Priority")
)
View Source 
var (
	TestLogIdKey            = bsonutil.MustHaveTag(TestLog{}, "Id")
	TestLogNameKey          = bsonutil.MustHaveTag(TestLog{}, "Name")
	TestLogTaskKey          = bsonutil.MustHaveTag(TestLog{}, "Task")
	TestLogTaskExecutionKey = bsonutil.MustHaveTag(TestLog{}, "TaskExecution")
	TestLogLinesKey         = bsonutil.MustHaveTag(TestLog{}, "Lines")
)
View Source 
var EarliestDateToConsider time.Time
View Source 
var (
	TestLogPath = "/test_log/"
)
View Source 
var (
	ValidRepoTypes = []string{GithubRepoType}
)

valid repositories - currently only github supported

Functions

func AbortBuild 

func AbortBuild(buildId string, caller string) error

AbortBuild sets the abort flag on all tasks associated with the build which are in an abortable state, and marks the build as deactivated.

func AbortTask 

func AbortTask(taskId, caller string) error

func AbortVersion 

func AbortVersion(versionId string) error

AbortVersion sets the abort flag on all tasks associated with the version which are in an abortable state

func ActivatePreviousTask 

func ActivatePreviousTask(taskId, caller string) error

ActivatePreviousTask will set the Active state for the first task with a revision order number less than the current task's revision order number.

func AddNewBuildsForPatch 

func AddNewBuildsForPatch(p *patch.Patch, patchVersion *version.Version, project *Project, pairs TVPairSet) error

Given a patch version and a list of variant/task pairs, creates the set of new builds that do not exist yet out of the set of pairs. No tasks are added for builds which already exist (see AddNewTasksForPatch).

func AddNewTasksForPatch 

func AddNewTasksForPatch(p *patch.Patch, patchVersion *version.Version, project *Project, pairs TVPairSet) error

Given a patch version and set of variant/task pairs, creates any tasks that don't exist yet, within the set of already existing builds.

func AddTasksToBuild 

func AddTasksToBuild(b *build.Build, project *Project, v *version.Version,
	taskNames []string) (*build.Build, error)

AddTasksToBuild creates the tasks for the given build of a project

func AddUserPublicKey 

func AddUserPublicKey(userId, name, value string) error

AddUserPublicKey adds a public key to a user's saved key list

func CalculateActualMakespan 

func CalculateActualMakespan(tasks []task.Task) time.Duration

CalculateActualMakespan finds the amount of time it took for the build to complete from the first task start to the last task finishing.

func CancelPatch 

func CancelPatch(p *patch.Patch, caller string) error

func CreateBuildFromVersion 

func CreateBuildFromVersion(project *Project, v *version.Version, tt TaskIdTable,
	buildName string, activated bool, taskNames []string) (string, error)

CreateBuildFromVersion creates a build given all of the necessary information from the corresponding version and project and a list of tasks.

func CreateTasksCache 

func CreateTasksCache(tasks []task.Task) []build.TaskCache

func DeactivatePreviousTasks 

func DeactivatePreviousTasks(taskId, caller string) error

Deactivate any previously activated but undispatched tasks for the same build variant + display name + project combination as the task.

func DeleteBuild 

func DeleteBuild(id string) error

DeleteBuild removes any record of the build by removing it and all of the tasks that are a part of it from the database.

func FinalizePatch 

func FinalizePatch(p *patch.Patch, settings *evergreen.Settings) (*version.Version, error)

Finalizes a patch: Patches a remote project's configuration file if needed. Creates a version for this patch and links it. Creates builds based on the version.

func FindLastPassingVersionForBuildVariants 

func FindLastPassingVersionForBuildVariants(project *Project, buildVariantNames []string) (*version.Version, error)

Given a project name and a list of build variants, return the latest version on which all the given build variants succeeded. Gives up after 100 versions.

func FindMinimumQueuePositionForTask 

func FindMinimumQueuePositionForTask(taskId string) (int, error)

FindMinimumQueuePositionForTask finds the position of a task in the many task queues where its position is the lowest. It returns an error if the aggregation it runs fails.

func FindPredictedMakespan 

func FindPredictedMakespan(tasks []task.Task) dependencyPath

FindPredictedMakespan, given a list of tasks that have been completed, finds the optimal makespan of that build.

func GetNewRevisionOrderNumber 

func GetNewRevisionOrderNumber(projectId string) (int, error)

GetNewRevisionOrderNumber gets a new revision order number for a project.

func GetOrCreateUser 

func GetOrCreateUser(userId, displayName, email string) (*user.DBUser, error)

GetOrCreateUser fetches a user with the given userId and returns it. If no document exists for that userId, inserts it along with the provided display name and email.

func GetRawTaskLogChannel 

func GetRawTaskLogChannel(taskId string, execution int, severities []string,
	msgTypes []string) (chan LogMessage, error)

func GetTaskExpectedDuration 

func GetTaskExpectedDuration(task task.Task,
	allDurations ProjectTaskDurations) time.Duration

GetTaskExpectedDuration returns the expected duration for a given task if the task does not exist, it returns model.DefaultTaskDuration

func InsertNotificationRecord 

func InsertNotificationRecord(prevNotification, currNotification,
	notificationName, notificationType, notificationProject,
	notificationRequester string) error

func LastNotificationsEventTime 

func LastNotificationsEventTime(projectName string) (time.Time,
	error)

func LoadProjectInto 

func LoadProjectInto(data []byte, identifier string, project *Project) error

LoadProjectInto loads the raw data from the config file into project and sets the project's identifier field to identifier. Tags are evaluateed.

func MarkEnd 

func MarkEnd(taskId, caller string, finishTime time.Time, detail *apimodels.TaskEndDetail,
	p *Project, deactivatePrevious bool) error

MarkEnd updates the task as being finished, performs a stepback if necessary, and updates the build status

func MarkStart 

func MarkStart(taskId string) error

MarkStart updates the task, build, version and if necessary, patch documents with the task start time

func MarkTaskDispatched 

func MarkTaskDispatched(t *task.Task, hostId, distroId string) error

func MarkTaskUndispatched 

func MarkTaskUndispatched(t *task.Task) error

func MarkVersionCompleted 

func MarkVersionCompleted(versionId string, finishTime time.Time) error

MarkVersionCompleted updates the status of a completed version to reflect its correct state by checking the status of its individual builds.

func MarkVersionStarted 

func MarkVersionStarted(versionId string, startTime time.Time) error

func NewAxisSelectorEvaluator 

func NewAxisSelectorEvaluator(axes []matrixAxis) *axisSelectorEvaluator

func NewParserTaskSelectorEvaluator 

func NewParserTaskSelectorEvaluator(tasks []parserTask) *taskSelectorEvaluator

NewParserTaskSelectorEvaluator returns a new taskSelectorEvaluator.

func NewVariantSelectorEvaluator 

func NewVariantSelectorEvaluator(variants []parserBV, ase *axisSelectorEvaluator) *variantSelectorEvaluator

NewVariantSelectorEvaluator returns a new taskSelectorEvaluator.

func NextTaskForHost 

func NextTaskForHost(h *host.Host) (*task.Task, error)

NextTaskForHost the next task that should be run on the host.

func RefreshTasksCache 

func RefreshTasksCache(buildId string) error

RefreshTasksCache updates a build document so that the tasks cache reflects the correct current state of the tasks it represents.

func RestartBuild 

func RestartBuild(buildId string, taskIds []string, abortInProgress bool, caller string) error

RestartBuild restarts completed tasks associated with a given buildId. If abortInProgress is true, it also sets the abort flag on any in-progress tasks.

func RestartVersion 

func RestartVersion(versionId string, taskIds []string, abortInProgress bool, caller string) error

RestartVersion restarts completed tasks associated with a given versionId. If abortInProgress is true, it also sets the abort flag on any in-progress tasks.

func SaveUserSettings 

func SaveUserSettings(userId string, settings user.UserSettings) error

SaveUserSettings updates the settings stored for the given user id.

func SetActiveState 

func SetActiveState(taskId string, caller string, active bool) error

func SetBuildActivation 

func SetBuildActivation(buildId string, active bool, caller string) error

SetBuildActivation updates the "active" state of this build and all associated tasks. It also updates the task cache for the build document.

func SetBuildPriority 

func SetBuildPriority(buildId string, priority int64) error

SetBuildPriority updates the priority field of all tasks associated with the given build id.

func SetLastNotificationsEventTime 

func SetLastNotificationsEventTime(projectName string,
	timeOfEvent time.Time) error

Record the last-notification time for a given project.

func SetProcessRuntimeCompleted 

func SetProcessRuntimeCompleted(processName string,
	runtime time.Duration) error

Updates a process runtime to set recent_success to the current time. If no process with the given name exists, create it. Parameter "processName" should be a constant "mci package" name from globals.go

func SetUserAPIKey 

func SetUserAPIKey(userId, newKey string) error

SetUserAPIKey updates the API key stored with a user.

func SetVersionActivation 

func SetVersionActivation(versionId string, active bool, caller string) error

SetVersionActivation updates the "active" state of all builds and tasks associated with a version to the given setting. It also updates the task cache for all builds affected.

func SetVersionPriority 

func SetVersionPriority(versionId string, priority int64) error

func TVPairsToVariantTasks 

func TVPairsToVariantTasks(in []TVPair) []patch.VariantTasks

TVPairsToVariantTasks takes a list of TVPairs (task/variant pairs), groups the tasks for the same variant together under a single list, and return all the variant groups as a set of patch.VariantTasks.

func TryMarkPatchBuildFinished 

func TryMarkPatchBuildFinished(b *build.Build, finishTime time.Time) error

TryMarkPatchBuildFinished attempts to mark a patch as finished if all the builds for the patch are finished as well

func TryResetTask 

func TryResetTask(taskId, user, origin string, p *Project, detail *apimodels.TaskEndDetail) error

TryResetTask resets a task

func UntrackStaleProjectRefs 

func UntrackStaleProjectRefs(activeProjects []string) error

UntrackStaleProjectRefs sets all project_refs in the db not in the array of project identifiers to "untracked."

func UpdateBuildAndVersionStatusForTask 

func UpdateBuildAndVersionStatusForTask(taskId string) error

UpdateBuildStatusForTask finds all the builds for a task and updates the status of the build based on the task's status.

func UpdateLastRevision 

func UpdateLastRevision(projectId, revision string) error

UpdateLastRevision updates the last created revision of a project.

func UpdateOneNotification 

func UpdateOneNotification(query interface{}, update interface{}) error

func UpdateStaticHosts 

func UpdateStaticHosts(e *evergreen.Settings) error

func UpdateTaskQueue 

func UpdateTaskQueue(distro string, taskQueue []TaskQueueItem) error

func UpsertOneProcessRuntime 

func UpsertOneProcessRuntime(query interface{}, update interface{}) error

func ValidateTVPairs 

func ValidateTVPairs(p *Project, in []TVPair) error

ValidateTVPairs checks that all of a set of variant/task pairs exist in a given project.

Types

type AlertConfig 

type AlertConfig struct {
	Provider string `bson:"provider" json:"provider"` //e.g. e-mail, flowdock, SMS

	// Data contains provider-specific on how a notification should be delivered.
	// Typed as bson.M so that the appropriate provider can parse out necessary details
	Settings bson.M `bson:"settings" json:"settings"`
}

type ArtifactInstructions 

type ArtifactInstructions struct {
	Include      []string `yaml:"include,omitempty" bson:"include"`
	ExcludeFiles []string `yaml:"excludefiles,omitempty" bson:"exclude_files"`
}

type AvgBucket 

type AvgBucket struct {
	Id          int           `bson:"_id" json:"index" csv:"index"`
	AverageTime time.Duration `bson:"a" json:"avg" csv:"avg_time"`
	NumberTasks int           `bson:"n" json:"number_tasks" csv:"number_tasks"`
	Start       time.Time     `json:"start_time" csv:"start_time"`
	End         time.Time     `json:"end_time" csv:"end_time"`
}

AvgBucket is one element in the results of a list of buckets that are created from the agg query.

type AvgBuckets 

type AvgBuckets []AvgBucket

func AverageStatistics 

func AverageStatistics(distroId string, bounds FrameBounds) (AvgBuckets, error)

AverageStatistics uses an agg pipeline that creates buckets given a time frame and finds the average scheduled -> start time for that time frame. One thing to note is that the average time is in milliseconds, not nanoseconds and must be converted.

type Bucket 

type Bucket struct {
	TotalTime time.Duration  `json:"total_time"`
	Resources []ResourceInfo `json:"resources"`
}

Bucket stores the total amount of time in a given bucket and a list of the resources that are in that bucket

func CreateHostBuckets 

func CreateHostBuckets(hosts []host.Host, bounds FrameBounds) ([]Bucket, []error)

CreateHostBuckets takes in a list of hosts with their creation and termination times and returns durations bucketed based on a start time, number of buckets and the size of each bucket

func CreateTaskBuckets 

func CreateTaskBuckets(tasks []task.Task, oldTasks []task.Task, bounds FrameBounds) ([]Bucket, []error)

CreateTaskBuckets takes in a list of tasks with their start and finish times and returns durations bucketed based on a start time, number of buckets and the size of each bucket

type BuildStatusDiff 

type BuildStatusDiff struct {
	Name  string           `json:"name"`
	Diff  StatusDiff       `json:"diff"`
	Tasks []TaskStatusDiff `json:"tasks"`
}

BuildStatusDiff stores a diff of two build statuses.

func StatusDiffBuilds 

func StatusDiffBuilds(original, patch *build.Build) BuildStatusDiff

StatusDiffBuilds takes two builds and returns a diff of their results for easy comparison and analysis.

type BuildVariant 

type BuildVariant struct {
	Name        string            `yaml:"name,omitempty" bson:"name"`
	DisplayName string            `yaml:"display_name,omitempty" bson:"display_name"`
	Expansions  map[string]string `yaml:"expansions,omitempty" bson:"expansions"`
	Modules     []string          `yaml:"modules,omitempty" bson:"modules"`
	Disabled    bool              `yaml:"disabled,omitempty" bson:"disabled"`
	Tags        []string          `yaml:"tags,omitempty" bson:"tags"`
	Push        bool              `yaml:"push,omitempty" bson:"push"`

	// Use a *int for 2 possible states
	// nil - not overriding the project setting
	// non-nil - overriding the project setting with this BatchTime
	BatchTime *int `yaml:"batchtime,omitempty" bson:"batchtime,omitempty"`

	// Use a *bool so that there are 3 possible states:
	//   1. nil   = not overriding the project setting (default)
	//   2. true  = overriding the project setting with true
	//   3. false = overriding the project setting with false
	Stepback *bool `yaml:"stepback,omitempty" bson:"stepback,omitempty"`

	// the default distros.  will be used to run a task if no distro field is
	// provided for the task
	RunOn []string `yaml:"run_on,omitempty" bson:"run_on"`

	// all of the tasks to be run on the build variant, compile through tests.
	Tasks []BuildVariantTask `yaml:"tasks,omitempty" bson:"tasks"`
}

type BuildVariantHistoryIterator 

type BuildVariantHistoryIterator interface {
	GetItems(beforeCommit *version.Version, numCommits int) ([]bson.M, []version.Version, error)
}

Interface around getting task and version history for a given build variant in a given project.

func NewBuildVariantHistoryIterator 

func NewBuildVariantHistoryIterator(buildVariantInTask string, buildVariantInVersion string,
	projectName string) BuildVariantHistoryIterator

Since version currently uses build variant display name and task uses build variant name, we need both.

type BuildVariantTask 

type BuildVariantTask struct {
	// Name has to match the name field of one of the tasks specified at
	// the project level, or an error will be thrown
	Name string `yaml:"name,omitempty" bson:"name"`

	// fields to overwrite ProjectTask settings
	Patchable *bool             `yaml:"patchable,omitempty" bson:"patchable,omitempty"`
	Priority  int64             `yaml:"priority,omitempty" bson:"priority"`
	DependsOn []TaskDependency  `yaml:"depends_on,omitempty" bson:"depends_on"`
	Requires  []TaskRequirement `yaml:"requires,omitempty" bson:"requires"`

	// currently unsupported (TODO EVG-578)
	ExecTimeoutSecs int   `yaml:"exec_timeout_secs,omitempty" bson:"exec_timeout_secs"`
	Stepback        *bool `yaml:"stepback,omitempty" bson:"stepback,omitempty"`

	// the distros that the task can be run on
	Distros []string `yaml:"distros,omitempty" bson:"distros"`
}

Unmarshalled from the "tasks" list in an individual build variant

func (*BuildVariantTask) Populate 

func (bvt *BuildVariantTask) Populate(pt ProjectTask)

Populate updates the base fields of the BuildVariantTask with fields from the project task definition.

func (*BuildVariantTask) UnmarshalYAML 

func (bvt *BuildVariantTask) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML allows tasks to be referenced as single selector strings. This works by first attempting to unmarshal the YAML into a string and then falling back to the BuildVariantTask struct.

type BuildVariantTaskDurations 

type BuildVariantTaskDurations struct {
	TaskDurationByBuildVariant map[string]*TaskDurations
}

BuildVariantTaskDurations maintains a mapping between a buildvariant and its accompanying TaskDurations

type CLISettings 

type CLISettings struct {
	APIServerHost string        `json:"api_server_host" yaml:"api_server_host,omitempty"`
	UIServerHost  string        `json:"ui_server_host" yaml:"ui_server_host,omitempty"`
	APIKey        string        `json:"api_key" yaml:"api_key,omitempty"`
	User          string        `json:"user" yaml:"user,omitempty"`
	Projects      []ProjectConf `json:"projects" yaml:"projects,omitempty"`
	LoadedFrom    string        `json:"-" yaml:"-"`
}

CLISettings represents the data stored in the user's config file, by default located at ~/.evergreen.yml

func (*CLISettings) FindDefaultProject 

func (s *CLISettings) FindDefaultProject() string

func (*CLISettings) FindDefaultTasks 

func (s *CLISettings) FindDefaultTasks(project string) []string

func (*CLISettings) FindDefaultVariants 

func (s *CLISettings) FindDefaultVariants(project string) []string

func (*CLISettings) SetDefaultProject 

func (s *CLISettings) SetDefaultProject(name string)

func (*CLISettings) SetDefaultTasks 

func (s *CLISettings) SetDefaultTasks(project string, tasks ...string)

func (*CLISettings) SetDefaultVariants 

func (s *CLISettings) SetDefaultVariants(project string, variants ...string)

type Context 

type Context struct {
	Task       *task.Task
	Build      *build.Build
	Version    *version.Version
	Patch      *patch.Patch
	Project    *Project
	ProjectRef *ProjectRef
}

Context is the set of all the related entities in a task/build/version/project hierarchy. Using the LoadContext function, all the other applicable fields in the Context can inferred and populated from the id of any one of the fields.

func LoadContext 

func LoadContext(taskId, buildId, versionId, patchId, projectId string) (Context, error)

LoadContext builds a Context from the set of given resource ID's by inferring all the relationships between them - for example, e.g. loading a project based on the the task, or the version based on the patch, etc.

type EmailAlertData 

type EmailAlertData struct {
	Recipients []string `bson:"recipients"`
}

type ExhaustedIterator 

type ExhaustedIterator struct {
	Before, After bool
}

type FrameBounds 

type FrameBounds struct {
	StartTime     time.Time
	EndTime       time.Time
	BucketSize    time.Duration
	NumberBuckets int
}

FrameBounds is a set of information about the inputs of buckets

func CalculateBounds 

func CalculateBounds(daysBack, granularity int) FrameBounds

CalculateBounds takes in a daysBack and granularity and returns the start time, end time, bucket size, and number of buckets

type HostTaskInconsistency 

type HostTaskInconsistency struct {
	Host          string
	HostTaskCache string
	Task          string
	TaskHostCache string
}

HostTaskInconsistency represents a mismatch between task and host documents. It contains both the host and task's view of their relationship. Implements the Error interface, which returns a full string describing the nature of the mismatch.

func AuditHostTaskConsistency 

func AuditHostTaskConsistency() ([]HostTaskInconsistency, error)

AuditHostTaskConsistency finds all running tasks and running hosts and compares their caches of what host/task they are assigned to. Returns a slice of any mappings that are not 1:1 and any errors that occur.

NOTE: the error returned ONLY represents issues communicating with the database. HostTaskInconsistency implements the error interface, but it is up to the caller to cast the inconsistencies into an error type if they desire.

func (HostTaskInconsistency) Error 

func (i HostTaskInconsistency) Error() string

Error returns a human-readible explanation of a HostTaskInconsistency.

type HostUtilizationBucket 

type HostUtilizationBucket struct {
	StaticHost  time.Duration `json:"static_host" csv:"static_host"`
	DynamicHost time.Duration `json:"dynamic_host" csv:"dynamic_host"`
	Task        time.Duration `json:"task" csv:"task"`
	StartTime   time.Time     `json:"start_time" csv:"start_time"`
	EndTime     time.Time     `json:"end_time" csv:"end_time"`
}

HostUtilizationBucket represents an aggregate view of the hosts and tasks Bucket for a given time frame.

func CreateAllHostUtilizationBuckets 

func CreateAllHostUtilizationBuckets(daysBack, granularity int) ([]HostUtilizationBucket, error)

CreateAllHostUtilizationBuckets aggregates each bucket by creating a time frame given the number of days back and the granularity wanted (ie. days, minutes, seconds, hours) all in seconds. It returns a list of Host utilization information for each bucket.

type LogMessage 

type LogMessage struct {
	Type      string    `bson:"t" json:"t"`
	Severity  string    `bson:"s" json:"s"`
	Message   string    `bson:"m" json:"m"`
	Timestamp time.Time `bson:"ts" json:"ts"`
	Version   int       `bson:"v" json:"v"`
}

func FindMostRecentLogMessages 

func FindMostRecentLogMessages(taskId string, execution int, numMsgs int,
	severities []string, msgTypes []string) ([]LogMessage, error)

note: to ignore severity or type filtering, pass in empty slices

func (*LogMessage) Insert 

func (self *LogMessage) Insert(taskId string, execution int) error

type Module 

type Module struct {
	Name   string `yaml:"name,omitempty" bson:"name"`
	Branch string `yaml:"branch,omitempty" bson:"branch"`
	Repo   string `yaml:"repo,omitempty" bson:"repo"`
	Prefix string `yaml:"prefix,omitempty" bson:"prefix"`
}

func (*Module) GetRepoOwnerAndName 

func (m *Module) GetRepoOwnerAndName() (string, string)

type NotificationHistory 

type NotificationHistory struct {
	Id                    bson.ObjectId `bson:"_id,omitempty"`
	PrevNotificationId    string        `bson:"p_nid"`
	CurrNotificationId    string        `bson:"c_nid"`
	NotificationName      string        `bson:"n_name"`
	NotificationType      string        `bson:"n_type"`
	NotificationTime      time.Time     `bson:"n_time"`
	NotificationProject   string        `bson:"n_branch"`
	NotificationRequester string        `bson:"n_requester"`
}

func FindNotificationRecord 

func FindNotificationRecord(notificationId, notificationName, notificationType,
	notificationProject, notificationRequester string) (*NotificationHistory,
	error)

func FindOneNotification 

func FindOneNotification(query interface{},
	projection interface{}) (*NotificationHistory, error)

func (*NotificationHistory) Insert 

func (self *NotificationHistory) Insert() error

type PluginCommandConf 

type PluginCommandConf struct {
	Function string `yaml:"func,omitempty" bson:"func"`
	// Type is used to differentiate between setup related commands and actual
	// testing commands.
	Type string `yaml:"type,omitempty" bson:"type"`

	// DisplayName is a human readable description of the function of a given
	// command.
	DisplayName string `yaml:"display_name,omitempty" bson:"display_name"`

	// Command is a unique identifier for the command configuration. It consists of a
	// plugin name and a command name.
	Command string `yaml:"command,omitempty" bson:"command"`

	// Variants is used to enumerate the particular sets of buildvariants to run
	// this command configuration on. If it is empty, it is run on all defined
	// variants.
	Variants []string `yaml:"variants,omitempty" bson:"variants"`

	// TimeoutSecs indicates the maximum duration the command is allowed to run
	// for. If undefined, it is unbounded.
	TimeoutSecs int `yaml:"timeout_secs,omitempty" bson:"timeout_secs"`

	// Params are used to supply configuratiion specific information.
	Params map[string]interface{} `yaml:"params,omitempty" bson:"params"`

	// Vars defines variables that can be used within commands.
	Vars map[string]string `yaml:"vars,omitempty" bson:"vars"`
}

func (PluginCommandConf) GetDisplayName 

func (p PluginCommandConf) GetDisplayName() string

GetDisplayName returns the display name of the plugin command. If none is defined, it returns the command's identifier.

func (PluginCommandConf) GetType 

func (p PluginCommandConf) GetType(prj *Project) string

GetType returns the type of this command if one is explicitly specified. If no type is specified, it checks the default command type of the project. If one is specified, it returns that, if not, it returns the DefaultCommandType.

func (PluginCommandConf) RunOnVariant 

func (p PluginCommandConf) RunOnVariant(variant string) bool

RunOnVariant returns true if the plugin command should run on variant; returns false otherwise

type ProcessRuntime 

type ProcessRuntime struct {
	Id         string        `bson:"_id"         json:"id"`
	FinishedAt time.Time     `bson:"finished_at" json:"finished_at"`
	Runtime    time.Duration `bson:"runtime"     json:"runtime"`
}

ProcessRuntime tracks the most recent success ping by a given MCI process by storing it in mongodb. Id is a package name (see globals.go), FinishedAt is a time representing the most recent completion of that process, and Runtime is the duration of time the process took to run

func FindAllLateProcessRuntimes 

func FindAllLateProcessRuntimes(cutoff time.Time) ([]ProcessRuntime, error)

Finds all runtimes that were updated before (less than) given time.

func FindAllProcessRuntimes 

func FindAllProcessRuntimes(query interface{},
	projection interface{}) ([]ProcessRuntime, error)

func FindEveryProcessRuntime 

func FindEveryProcessRuntime() ([]ProcessRuntime, error)

Returns list of all process runtime entries

func FindOneProcessRuntime 

func FindOneProcessRuntime(query interface{},
	projection interface{}) (*ProcessRuntime, error)

func FindProcessRuntime 

func FindProcessRuntime(id string) (*ProcessRuntime, error)

Finds a process runtime by Id

type Project 

type Project struct {
	Enabled         bool                       `yaml:"enabled,omitempty" bson:"enabled"`
	Stepback        bool                       `yaml:"stepback,omitempty" bson:"stepback"`
	BatchTime       int                        `yaml:"batchtime,omitempty" bson:"batch_time"`
	Owner           string                     `yaml:"owner,omitempty" bson:"owner_name"`
	Repo            string                     `yaml:"repo,omitempty" bson:"repo_name"`
	RemotePath      string                     `yaml:"remote_path,omitempty" bson:"remote_path"`
	RepoKind        string                     `yaml:"repokind,omitempty" bson:"repo_kind"`
	Branch          string                     `yaml:"branch,omitempty" bson:"branch_name"`
	Identifier      string                     `yaml:"identifier,omitempty" bson:"identifier"`
	DisplayName     string                     `yaml:"display_name,omitempty" bson:"display_name"`
	CommandType     string                     `yaml:"command_type,omitempty" bson:"command_type"`
	Ignore          []string                   `yaml:"ignore,omitempty" bson:"ignore"`
	Pre             *YAMLCommandSet            `yaml:"pre,omitempty" bson:"pre"`
	Post            *YAMLCommandSet            `yaml:"post,omitempty" bson:"post"`
	Timeout         *YAMLCommandSet            `yaml:"timeout,omitempty" bson:"timeout"`
	CallbackTimeout int                        `yaml:"callback_timeout_secs,omitempty" bson:"callback_timeout_secs"`
	Modules         []Module                   `yaml:"modules,omitempty" bson:"modules"`
	BuildVariants   []BuildVariant             `yaml:"buildvariants,omitempty" bson:"build_variants"`
	Functions       map[string]*YAMLCommandSet `yaml:"functions,omitempty" bson:"functions"`
	Tasks           []ProjectTask              `yaml:"tasks,omitempty" bson:"tasks"`
	ExecTimeoutSecs int                        `yaml:"exec_timeout_secs,omitempty" bson:"exec_timeout_secs"`

	// Flag that indicates a project as requiring user authentication
	Private bool `yaml:"private,omitempty" bson:"private"`
}

func FindProject 

func FindProject(revision string, projectRef *ProjectRef) (*Project, error)

func MakePatchedConfig 

func MakePatchedConfig(p *patch.Patch, remoteConfigPath, projectConfig string) (
	*Project, error)

MakePatchedConfig takes in the path to a remote configuration a stringified version of the current project and returns an unmarshalled version of the project with the patch applied

func (*Project) FindAllBuildVariantTasks 

func (p *Project) FindAllBuildVariantTasks() []BuildVariantTask

FindAllBuildVariantTasks returns every BuildVariantTask, fully populated, for all variants of a project.

func (*Project) FindAllVariants 

func (p *Project) FindAllVariants() []string

func (*Project) FindBuildVariant 

func (p *Project) FindBuildVariant(build string) *BuildVariant

func (*Project) FindProjectTask 

func (p *Project) FindProjectTask(name string) *ProjectTask

func (*Project) FindTaskForVariant 

func (p *Project) FindTaskForVariant(task, variant string) *BuildVariantTask

func (*Project) FindTasksForVariant 

func (p *Project) FindTasksForVariant(build string) []string

func (*Project) FindVariantsWithTask 

func (p *Project) FindVariantsWithTask(task string) []string

FindVariantsWithTask returns the name of each variant containing the given task name.

func (*Project) GetModuleByName 

func (p *Project) GetModuleByName(name string) (*Module, error)

func (Project) GetSpecForTask 

func (p Project) GetSpecForTask(name string) ProjectTask

GetSpecForTask returns a ProjectTask spec for the given name. Returns an empty ProjectTask if none exists.

func (*Project) GetVariantMappings 

func (p *Project) GetVariantMappings() map[string]string

func (*Project) GetVariantsWithTask 

func (p *Project) GetVariantsWithTask(taskName string) []string

func (*Project) IgnoresAllFiles 

func (p *Project) IgnoresAllFiles(files []string) bool

IgnoresAllFiles takes in a slice of filepaths and checks to see if all files are matched by the project's Ignore regular expressions.

type ProjectConf 

type ProjectConf struct {
	Name     string   `json:"name" yaml:"name,omitempty"`
	Default  bool     `json:"default" yaml:"default,omitempty"`
	Variants []string `json:"variants" yaml:"variants,omitempty"`
	Tasks    []string `json:"tasks" yaml:"tasks,omitempty"`
}

type ProjectNotificationTime 

type ProjectNotificationTime struct {
	ProjectName               string    `bson:"_id"`
	LastNotificationEventTime time.Time `bson:"last_notification_event_time"`
}

type ProjectRef 

type ProjectRef struct {
	Owner              string `bson:"owner_name" json:"owner_name" yaml:"owner"`
	Repo               string `bson:"repo_name" json:"repo_name" yaml:"repo"`
	Branch             string `bson:"branch_name" json:"branch_name" yaml:"branch"`
	RepoKind           string `bson:"repo_kind" json:"repo_kind" yaml:"repokind"`
	Enabled            bool   `bson:"enabled" json:"enabled" yaml:"enabled"`
	Private            bool   `bson:"private" json:"private" yaml:"private"`
	BatchTime          int    `bson:"batch_time" json:"batch_time" yaml:"batchtime"`
	RemotePath         string `bson:"remote_path" json:"remote_path" yaml:"remote_path"`
	Identifier         string `bson:"identifier" json:"identifier" yaml:"identifier"`
	DisplayName        string `bson:"display_name" json:"display_name" yaml:"display_name"`
	LocalConfig        string `bson:"local_config" json:"local_config" yaml:"local_config"`
	DeactivatePrevious bool   `bson:"deactivate_previous" json:"deactivate_previous" yaml:"deactivate_previous"`
	//Tracked determines whether or not the project is discoverable in the UI
	Tracked bool `bson:"tracked" json:"tracked"`

	// Admins contain a list of users who are able to access the projects page.
	Admins []string `bson:"admins" json:"admins"`

	// The "Alerts" field is a map of trigger (e.g. 'task-failed') to
	// the set of alert deliveries to be processed for that trigger.
	Alerts map[string][]AlertConfig `bson:"alert_settings" json:"alert_config,omitempty"`

	// RepoDetails contain the details of the status of the consistency
	// between what is in GitHub and what is in Evergreen
	RepotrackerError *RepositoryErrorDetails `bson:"repotracker_error" json:"repotracker_error"`
}

The ProjectRef struct contains general information, independent of any revision control system, needed to track a given project

func FindAllProjectRefs 

func FindAllProjectRefs() ([]ProjectRef, error)

FindAllProjectRefs returns all project refs in the db

func FindAllTrackedProjectRefs 

func FindAllTrackedProjectRefs() ([]ProjectRef, error)

FindAllTrackedProjectRefs returns all project refs in the db that are currently being tracked (i.e. their project files still exist)

func FindOneProjectRef 

func FindOneProjectRef(identifier string) (*ProjectRef, error)

FindOneProjectRef gets a project ref given the owner name, the repo name and the project name

func (*ProjectRef) GetBatchTime 

func (p *ProjectRef) GetBatchTime(variant *BuildVariant) int

GetBatchTime returns the Batch Time of the ProjectRef

func (*ProjectRef) Insert 

func (projectRef *ProjectRef) Insert() error

func (*ProjectRef) Location 

func (projectRef *ProjectRef) Location() (string, error)

Location generates and returns the ssh hostname and path to the repo.

func (*ProjectRef) String 

func (projectRef *ProjectRef) String() string

ProjectRef returns a string representation of a ProjectRef

func (*ProjectRef) Upsert 

func (projectRef *ProjectRef) Upsert() error

Upsert updates the project ref in the db if an entry already exists, overwriting the existing ref. If no project ref exists, one is created

type ProjectTask 

type ProjectTask struct {
	Name            string              `yaml:"name,omitempty" bson:"name"`
	Priority        int64               `yaml:"priority,omitempty" bson:"priority"`
	ExecTimeoutSecs int                 `yaml:"exec_timeout_secs,omitempty" bson:"exec_timeout_secs"`
	DependsOn       []TaskDependency    `yaml:"depends_on,omitempty" bson:"depends_on"`
	Requires        []TaskRequirement   `yaml:"requires,omitempty" bson:"requires"`
	Commands        []PluginCommandConf `yaml:"commands,omitempty" bson:"commands"`
	Tags            []string            `yaml:"tags,omitempty" bson:"tags"`

	// Use a *bool so that there are 3 possible states:
	//   1. nil   = not overriding the project setting (default)
	//   2. true  = overriding the project setting with true
	//   3. false = overriding the project setting with false
	Patchable *bool `yaml:"patchable,omitempty" bson:"patchable,omitempty"`
	Stepback  *bool `yaml:"stepback,omitempty" bson:"stepback,omitempty"`
}

Unmarshalled from the "tasks" list in the project file

type ProjectTaskDurations 

type ProjectTaskDurations struct {
	TaskDurationByProject map[string]*BuildVariantTaskDurations
}

ProjectTaskDurations maintans a mapping of a given project's name and its accompanying BuildVariantTaskDurations

type ProjectVars 

type ProjectVars struct {

	//Should match the _id in the project it refers to
	Id string `bson:"_id" json:"_id"`

	//The actual mapping of variables for this project
	Vars map[string]string `bson:"vars" json:"vars"`

	//PrivateVars keeps track of which variables are private and should therefore not
	//be returned to the UI server.
	PrivateVars map[string]bool `bson:"private_vars" json:"private_vars"`
}

ProjectVars holds a map of variables specific to a given project. They can be fetched at run time by the agent, so that settings which are sensitive or subject to frequent change don't need to be hard-coded into yml files.

func FindOneProjectVars 

func FindOneProjectVars(projectId string) (*ProjectVars, error)

func (*ProjectVars) RedactPrivateVars 

func (projectVars *ProjectVars) RedactPrivateVars()

func (*ProjectVars) Upsert 

func (projectVars *ProjectVars) Upsert() (*mgo.ChangeInfo, error)

type PushLog 

type PushLog struct {
	Id bson.ObjectId `bson:"_id,omitempty"`

	//the permanent location of the pushed file.
	Location string `bson:"location"`

	//the task id of the push stage
	TaskId string `bson:"task_id"`

	CreateTime time.Time `bson:"create_time"`
	Revision   string    `bson:"githash"`
	Status     string    `bson:"status"`

	//copied from version for the task
	RevisionOrderNumber int `bson:"order"`
}

func FindOnePushLog 

func FindOnePushLog(query interface{}, projection interface{},
	sort []string) (*PushLog, error)

func FindPushLogAfter 

func FindPushLogAfter(fileLoc string, revisionOrderNumber int) (*PushLog, error)

FindNewerPushLog returns a PushLog item if there is a file pushed from this version or a newer one, or one already in progress.

func NewPushLog 

func NewPushLog(v *version.Version, task *task.Task, location string) *PushLog

func (*PushLog) Insert 

func (self *PushLog) Insert() error

func (*PushLog) UpdateStatus 

func (self *PushLog) UpdateStatus(newStatus string) error

type Repository 

type Repository struct {
	Project             string `bson:"_id"`
	LastRevision        string `bson:"last_revision"`
	RevisionOrderNumber int    `bson:"last_commit_number"`
}

Repository contains fields used to track projects.

func FindRepository 

func FindRepository(projectId string) (*Repository, error)

FindRepository gets the repository object of a project.

type RepositoryErrorDetails 

type RepositoryErrorDetails struct {
	Exists            bool   `bson:"exists" json:"exists"`
	InvalidRevision   string `bson:"invalid_revision" json:"invalid_revision"`
	MergeBaseRevision string `bson:"merge_base_revision" json:"merge_base_revision"`
}

RepositoryErrorDetails indicates whether or not there is an invalid revision and if there is one, what the guessed merge base revision is.

type ResourceInfo 

type ResourceInfo struct {
	Id    string      `json:"id"`
	Start time.Time   `json:"start"`
	End   time.Time   `json:"end"`
	Data  interface{} `json:"data"`
}

ResourceInfo contains the meta data about a given resource This includes the id of the resource, the overall start and finish time and any extra data that should be included about the resource.

type Revision 

type Revision struct {
	Author          string
	AuthorEmail     string
	RevisionMessage string
	Revision        string
	CreateTime      time.Time
}

type Selector 

type Selector []selectCriterion

Selector holds the information necessary to build a set of elements based on name and tag combinations.

func ParseSelector 

func ParseSelector(s string) Selector

ParseSelector reads in a set of selection criteria defined as a string. This function only parses; it does not evaluate. Returns nil on an empty selection string.

func (Selector) String 

func (s Selector) String() string

String returns a readable representation of the Selector.

type StatusDetailsDiff 

type StatusDetailsDiff struct {
	Original apimodels.TaskEndDetail `json:"original"`
	Patch    apimodels.TaskEndDetail `json:"patch"`
}

StatusDetailsDiff stores a pairing of status details for easy visualization/aggregation later.

type StatusDiff 

type StatusDiff struct {
	Original string `json:"original"`
	Patch    string `json:"patch"`
}

StatusDiff stores a pairing of status strings for easy visualization/aggregation later.

type StuckHostInconsistency 

type StuckHostInconsistency struct {
	Host        string `bson:"host_id"`
	RunningTask string `bson:"running_task"`
	TaskStatus  string `bson:"task_status"`
}

StuckHostInconsistncy represents hosts that have running tasks but the tasks have been marked as completed.

func CheckStuckHosts 

func CheckStuckHosts() ([]StuckHostInconsistency, error)

CheckStuckHosts queries for hosts that tasks that are completed but that still have them as a running task

func (StuckHostInconsistency) Error 

func (shi StuckHostInconsistency) Error() string

type TVPair 

type TVPair struct {
	Variant  string
	TaskName string
}

TVPair is a helper type for mapping bv/task pairs to ids.

func IncludePatchDependencies 

func IncludePatchDependencies(project *Project, tvpairs []TVPair) []TVPair

IncludePatchDependencies takes a project and a slice of variant/task pairs names and returns the expanded set of variant/task pairs to include all the dependencies/requirements for the given set of tasks. If any dependency is cross-variant, it will include the variant and task for that dependency.

func VariantTasksToTVPairs 

func VariantTasksToTVPairs(in []patch.VariantTasks) []TVPair

VariantTasksToTVPairs takes a set of variants and tasks (from both the old and new request formats) and builds a universal set of pairs that can be used to expand the dependency tree.

func (TVPair) String 

func (p TVPair) String() string

String returns the pair's name in a readable form.

type TVPairSet 

type TVPairSet []TVPair

func (TVPairSet) ByVariant 

func (tvps TVPairSet) ByVariant(variant string) TVPairSet

ByVariant returns a list of TVPairs filtered to include only those for the given variant

func (TVPairSet) TaskNames 

func (tvps TVPairSet) TaskNames(variant string) []string

TaskNames extracts the unique set of task names for a given variant in the set of task/variant pairs.

type TaskConfig 

type TaskConfig struct {
	Distro       *distro.Distro
	Version      *version.Version
	ProjectRef   *ProjectRef
	Project      *Project
	Task         *task.Task
	BuildVariant *BuildVariant
	Expansions   *command.Expansions
	WorkDir      string
}

func NewTaskConfig 

func NewTaskConfig(d *distro.Distro, v *version.Version, p *Project, t *task.Task, r *ProjectRef) (*TaskConfig, error)

type TaskDep 

type TaskDep struct {
	Id          string `bson:"task_id,omitempty" json:"task_id"`
	DisplayName string `bson:"display_name" json:"display_name"`
}

type TaskDependency 

type TaskDependency struct {
	Name          string `yaml:"name,omitempty" bson:"name"`
	Variant       string `yaml:"variant,omitempty" bson:"variant,omitempty"`
	Status        string `yaml:"status,omitempty" bson:"status,omitempty"`
	PatchOptional bool   `yaml:"patch_optional,omitempty" bson:"patch_optional,omitempty"`
}

TaskDependency holds configuration information about a task that must finish before the task that contains the dependency can run.

func (*TaskDependency) UnmarshalYAML 

func (td *TaskDependency) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML allows tasks to be referenced as single selector strings. This works by first attempting to unmarshal the YAML into a string and then falling back to the TaskDependency struct.

type TaskDetails 

type TaskDetails struct {
	TimedOut bool   `bson:"timed_out"`
	Status   string `bson:"st"`
}

type TaskDurations 

type TaskDurations struct {
	TaskDurationByDisplayName map[string]time.Duration
}

TaskDurations maintains a mapping between a given task (by display name) and its accompanying aggregate expected duration

type TaskHistory 

type TaskHistory struct {
	Id    string                  `bson:"_id" json:"_id"`
	Order string                  `bson:"order" json:"order"`
	Tasks []aggregatedTaskHistory `bson:"tasks" json:"tasks"`
}

type TaskHistoryChunk 

type TaskHistoryChunk struct {
	Tasks       []bson.M
	Versions    []version.Version
	FailedTests map[string][]task.TestResult
	Exhausted   ExhaustedIterator
}

type TaskHistoryIterator 

type TaskHistoryIterator interface {
	GetChunk(version *version.Version, numBefore, numAfter int, include bool) (TaskHistoryChunk, error)
	GetDistinctTestNames(numCommits int) ([]string, error)
}

func NewTaskHistoryIterator 

func NewTaskHistoryIterator(name string, buildVariants []string, projectName string) TaskHistoryIterator

type TaskIdTable 

type TaskIdTable map[TVPair]string

TaskIdTable is a map of [variant, task display name]->[task id].

func NewPatchTaskIdTable 

func NewPatchTaskIdTable(proj *Project, v *version.Version, patchConfig TVPairSet) TaskIdTable

NewPatchTaskIdTable constructs a new TaskIdTable (map of [variant, task display name]->[task id])

func NewTaskIdTable 

func NewTaskIdTable(p *Project, v *version.Version) TaskIdTable

TaskIdTable builds a TaskIdTable for the given version and project

func (TaskIdTable) AddId 

func (tt TaskIdTable) AddId(variant, taskName, id string)

AddId adds the Id for the task/variant combination to the table.

func (TaskIdTable) GetId 

func (tt TaskIdTable) GetId(variant, taskName string) string

GetId returns the Id for the given task on the given variant. Returns the empty string if the task/variant does not exist.

func (TaskIdTable) GetIdsForAllTasks 

func (tt TaskIdTable) GetIdsForAllTasks(currentVariant, taskName string) []string

GetIdsForTasks returns all task Ids for tasks on all variants != the current task. The current variant and task must be passed in to avoid cycle generation.

func (TaskIdTable) GetIdsForAllVariants 

func (tt TaskIdTable) GetIdsForAllVariants(taskName string) []string

GetIdsForAllVariants returns all task Ids for taskName on all variants.

func (TaskIdTable) GetIdsForAllVariantsExcluding 

func (tt TaskIdTable) GetIdsForAllVariantsExcluding(taskName string, exclude TVPair) []string

GetIdsForAllVariants returns all task Ids for taskName on all variants, excluding the specific task denoted by the task/variant pair.

type TaskLog 

type TaskLog struct {
	Id           bson.ObjectId `bson:"_id,omitempty" json:"_id,omitempty"`
	TaskId       string        `bson:"t_id" json:"t_id"`
	Execution    int           `bson:"e" json:"e"`
	Timestamp    time.Time     `bson:"ts" json:"ts"`
	MessageCount int           `bson:"c" json:"c"`
	Messages     []LogMessage  `bson:"m" json:"m"`
}

a single chunk of a task log

func FindAllTaskLogs 

func FindAllTaskLogs(taskId string, execution int) ([]TaskLog, error)

func FindMostRecentTaskLogs 

func FindMostRecentTaskLogs(taskId string, execution int, limit int) ([]TaskLog, error)

func FindTaskLogsBeforeTime 

func FindTaskLogsBeforeTime(taskId string, execution int, ts time.Time, limit int) ([]TaskLog, error)

func (*TaskLog) AddLogMessage 

func (self *TaskLog) AddLogMessage(msg LogMessage) error

func (*TaskLog) Insert 

func (self *TaskLog) Insert() error

type TaskQueue 

type TaskQueue struct {
	Id     bson.ObjectId   `bson:"_id,omitempty" json:"_id"`
	Distro string          `bson:"distro" json:"distro"`
	Queue  []TaskQueueItem `bson:"queue" json:"queue"`
}

represents the next n tasks to be run on hosts of the distro

func FindAllTaskQueues 

func FindAllTaskQueues() ([]TaskQueue, error)

func FindTaskQueueForDistro 

func FindTaskQueueForDistro(distroId string) (*TaskQueue, error)

func (*TaskQueue) DequeueTask 

func (self *TaskQueue) DequeueTask(taskId string) error

pull out the task with the specified id from both the in-memory and db versions of the task queue

func (*TaskQueue) IsEmpty 

func (self *TaskQueue) IsEmpty() bool

func (*TaskQueue) Length 

func (self *TaskQueue) Length() int

func (*TaskQueue) NextTask 

func (self *TaskQueue) NextTask() TaskQueueItem

func (*TaskQueue) Save 

func (self *TaskQueue) Save() error

type TaskQueueItem 

type TaskQueueItem struct {
	Id                  string        `bson:"_id" json:"_id"`
	DisplayName         string        `bson:"display_name" json:"display_name"`
	BuildVariant        string        `bson:"build_variant" json:"build_variant"`
	RevisionOrderNumber int           `bson:"order" json:"order"`
	Requester           string        `bson:"requester" json:"requester"`
	Revision            string        `bson:"gitspec" json:"gitspec"`
	Project             string        `bson:"project" json:"project"`
	ExpectedDuration    time.Duration `bson:"exp_dur" json:"exp_dur"`
	Priority            int64         `bson:"priority" json:"priority"`
}

type TaskRequirement 

type TaskRequirement struct {
	Name    string `yaml:"name,omitempty" bson:"name"`
	Variant string `yaml:"variant,omitempty" bson:"variant,omitempty"`
}

TaskRequirement represents tasks that must exist along with the requirement's holder. This is only used when configuring patches.

type TaskStatusDiff 

type TaskStatusDiff struct {
	Name         string            `json:"name"`
	Diff         StatusDetailsDiff `json:"diff"`
	Tests        []TestStatusDiff  `json:"tests"`
	Original     string            `json:"original"`
	Patch        string            `json:"patch"`
	BuildVariant string            `json:"build_variant"`
}

TaskStatusDiff stores a diff of two task statuses.

func StatusDiffTasks 

func StatusDiffTasks(original *task.Task, patch *task.Task) TaskStatusDiff

StatusDiffTasks takes two tasks and returns a diff of their results for easy comparison and analysis.

type TestHistoryParameters 

type TestHistoryParameters struct {
	Project        string    `json:"project"`
	TestNames      []string  `json:"test_names"`
	TaskNames      []string  `json:"task_names"`
	BuildVariants  []string  `json:"variants"`
	TaskStatuses   []string  `json:"task_statuses"`
	TestStatuses   []string  `json:"test_statuses"`
	BeforeRevision string    `json:"before_revision"`
	AfterRevision  string    `json:"after_revision"`
	BeforeDate     time.Time `json:"before_date"`
	AfterDate      time.Time `json:"after_date"`
	Sort           int       `json:"sort"`
	Limit          int       `json:"limit"`
}

TestHistoryParameters are the parameters that are used to retrieve Test Results.

func (*TestHistoryParameters) SetDefaultsAndValidate 

func (thp *TestHistoryParameters) SetDefaultsAndValidate() error

setDefaultsAndValidate sets the default for test history parameters that do not have values and validates the test parameters.

type TestHistoryResult 

type TestHistoryResult struct {
	TestFile        string  `bson:"tf"`
	TaskName        string  `bson:"tn"`
	TaskStatus      string  `bson:"task_status"`
	TestStatus      string  `bson:"test_status"`
	Revision        string  `bson:"r"`
	Project         string  `bson:"p"`
	TaskId          string  `bson:"tid"`
	BuildVariant    string  `bson:"bv"`
	StartTime       float64 `bson:"st"`
	EndTime         float64 `bson:"et"`
	Execution       int     `bson:"ex"`
	Url             string  `bson:"url"`
	UrlRaw          string  `bson:"url_r"`
	OldTaskId       string  `bson:"otid"`
	TaskTimedOut    bool    `bson:"to"`
	TaskDetailsType string  `bson:"tdt"`
	LogId           string  `bson:"lid"`
}

TestHistoryResult represents what is returned by the aggregation

func GetTestHistory 

func GetTestHistory(testHistoryParameters *TestHistoryParameters) ([]TestHistoryResult, error)

GetTestHistory takes in test history parameters, validates them, and returns the test results according to those parameters. It sets tasks failed and tests failed as default statuses if none are provided, and defaults to all tasks, tests, and variants if those are not set.

type TestLog 

type TestLog struct {
	Id            string   `bson:"_id" json:"_id"`
	Name          string   `json:"name" bson:"name"`
	Task          string   `json:"task" bson:"task"`
	TaskExecution int      `json:"execution" bson:"execution"`
	Lines         []string `json:"lines" bson:"lines"`
}

func FindOneTestLog 

func FindOneTestLog(name, task string, execution int) (*TestLog, error)

FindOneTestLog returns a TestLog, given the test's name, task id, and execution.

func FindOneTestLogById 

func FindOneTestLogById(id string) (*TestLog, error)

func (*TestLog) Insert 

func (self *TestLog) Insert() error

Insert inserts the TestLog into the database

func (*TestLog) URL 

func (self *TestLog) URL() string

URL returns the path to access the log based on its current fields. Does not error if fields are not set.

func (*TestLog) Validate 

func (self *TestLog) Validate() error

Validate makes sure the log will accessible in the database before the log itself is inserted. Returns an error if something is wrong.

type TestStatusDiff 

type TestStatusDiff struct {
	Name     string     `json:"name"`
	Diff     StatusDiff `json:"diff"`
	Original string     `json:"original"`
	Patch    string     `json:"patch"`
}

TestStatusDiff stores a diff of two test results.

type TestSuite 

type TestSuite struct {
	Name  string `yaml:"name,omitempty"`
	Phase string `yaml:"phase,omitempty"`
}

type YAMLCommandSet 

type YAMLCommandSet struct {
	SingleCommand *PluginCommandConf
	MultiCommand  []PluginCommandConf
}

func (*YAMLCommandSet) List 

func (c *YAMLCommandSet) List() []PluginCommandConf

func (*YAMLCommandSet) MarshalYAML 

func (c *YAMLCommandSet) MarshalYAML() (interface{}, error)

func (*YAMLCommandSet) UnmarshalYAML 

func (c *YAMLCommandSet) UnmarshalYAML(unmarshal func(interface{}) error) error

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.