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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL