model

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 struct {
	Include      []string `yaml:"include" bson:"include"`
	ExcludeFiles []string `yaml:"excludefiles" bson:"exclude_files"`
}

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

type BuildVariant struct {
	Name        string            `yaml:"name" bson:"name"`
	DisplayName string            `yaml:"display_name" bson:"display_name"`
	Expansions  map[string]string `yaml:"expansions" bson:"expansions"`
	Modules     []string          `yaml:"modules" bson:"modules"`
	Disabled    bool              `yaml:"disabled" bson:"disabled"`
	Push        bool              `yaml:"push" 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" bson:"run_on"`

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

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

type BuildVariantMatrix struct {
	MatrixParameters []MatrixParameter `yaml:"matrix_parameters" bson:"matrix_parameters"`
	Template         BuildVariant      `yaml:"template" bson:"template"`
}

type BuildVariantTask struct {
	// this 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" bson:"name"`

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

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

type Dependency struct {
	TaskId string `bson:"_id" json:"id"`
	Status string `bson:"status" json:"status"`
}

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

type ExhaustedIterator struct {
	Before, After bool
}

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"`
}

type MatrixParameter struct {
	Name   string                 `yaml:"name" bson:"name"`
	Values []MatrixParameterValue `yaml:"values" bson:"values"`
}

type MatrixParameterValue struct {
	Value      string            `yaml:"value" bson:"value"`
	Expansions map[string]string `yaml:"expansions" bson:"expansions"`
}

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

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"`
}

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

	// DisplayName is a human readable description of the function of a given
	// command.
	DisplayName string `yaml:"display_name" 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" 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" bson:"variants"`

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

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

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

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"`
}

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

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

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

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"`

	// 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"`
}

type ProjectTask struct {
	Name        string              `yaml:"name" bson:"name"`
	ExecTimeout int                 `yaml:"exec_timeout" bson:"exec_timeout"`
	DependsOn   []TaskDependency    `yaml:"depends_on" bson:"depends_on"`
	Commands    []PluginCommandConf `yaml:"commands" bson:"commands"`

	// 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"`
}

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

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"`
}

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"`
}

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

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

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

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

type TVPair struct {
	Variant  string
	TaskName string
}

type Task struct {
	Id     string `bson:"_id" json:"id"`
	Secret string `bson:"secret" json:"secret"`

	// time information for task
	// create - the time we created this task in our database
	// dispatch - it has been run to start on a remote host
	// push - the time the commit generating this build was pushed to the remote
	// start - the time the remote host it was scheduled on responded as
	//      successfully started
	// finish - the time the task was completed on the remote host
	CreateTime    time.Time `bson:"create_time" json:"create_time"`
	DispatchTime  time.Time `bson:"dispatch_time" json:"dispatch_time"`
	PushTime      time.Time `bson:"push_time" json:"push_time"`
	ScheduledTime time.Time `bson:"scheduled_time" json:"scheduled_time"`
	StartTime     time.Time `bson:"start_time" json:"start_time"`
	FinishTime    time.Time `bson:"finish_time" json:"finish_time"`

	Version  string `bson:"version" json:"version,omitempty"`
	Project  string `bson:"branch" json:"branch,omitempty"`
	Revision string `bson:"gitspec" json:"gitspec"`
	Priority int    `bson:"priority" json:"priority"`

	// only relevant if the task is running.  the time of the last heartbeat
	// sent back by the agent
	LastHeartbeat time.Time `bson:"last_heartbeat"`

	// used to indicate whether task should be scheduled to run
	Activated    bool         `bson:"activated" json:"activated"`
	BuildId      string       `bson:"build_id" json:"build_id"`
	DistroId     string       `bson:"distro" json:"distro"`
	BuildVariant string       `bson:"build_variant" json:"build_variant"`
	DependsOn    []Dependency `bson:"depends_on" json:"depends_on"`

	// Human-readable name
	DisplayName string `bson:"display_name" json:"display_name"`

	// The host the task was run on
	HostId string `bson:"host_id" json:"host_id"`

	// the number of times this task has been restarted
	Restarts            int    `bson:"restarts" json:"restarts",omitempty`
	Execution           int    `bson:"execution" json:"execution"`
	OldTaskId           string `bson:"old_task_id,omitempty" json:"old_task_id",omitempty`
	Archived            bool   `bson:"archived,omitempty" json:"archived",omitempty`
	RevisionOrderNumber int    `bson:"order,omitempty" json:"order,omitempty"`

	// task requester - this is used to help tell the
	// reason this task was created. e.g. it could be
	// because the repotracker requested it (via tracking the
	// repository) or it was triggered by a developer
	// patch request
	Requester string `bson:"r" json:"r"`

	// this represents the various stages the task could be in
	Status  string                  `bson:"status" json:"status"`
	Details apimodels.TaskEndDetail `bson:"details" json:"task_end_details"`
	Aborted bool                    `bson:"abort,omitempty" json:"abort"`

	// how long the task took to execute.  meaningless if the task is not finished
	TimeTaken time.Duration `bson:"time_taken" json:"time_taken"`

	// how long we expect the task to take from start to finish
	ExpectedDuration time.Duration `bson:"expected_duration,omitempty" json:"expected_duration,omitempty"`

	// test results captured and sent back by agent
	TestResults []TestResult `bson:"test_results" json:"test_results"`

	// position in queue for the queue where it's closest to the top
	MinQueuePos int `bson:"min_queue_pos" json:"min_queue_pos,omitempty"`
}

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

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

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

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

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

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

type TaskIdTable map[TVPair]string

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"`
}

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

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"`
}

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"`
}

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"`
}

type TestResult struct {
	Status    string  `json:"status" bson:"status"`
	TestFile  string  `json:"test_file" bson:"test_file"`
	URL       string  `json:"url" bson:"url,omitempty"`
	LogId     string  `json:"log_id,omitempty" bson:"log_id,omitempty"`
	LineNum   int     `json:"line_num,omitempty" bson:"line_num,omitempty"`
	ExitCode  int     `json:"exit_code" bson:"exit_code"`
	StartTime float64 `json:"start" bson:"start"`
	EndTime   float64 `json:"end" bson:"end"`
}

type TestResults struct {
	Results []TestResult `json:"results"`
}

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

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

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