events

type ApplyExecutor struct {
	VCSClient         vcs.ClientProxy
	Terraform         *terraform.Client
	RequireApproval   bool
	Run               *run.Run
	Workspace         Workspace
	ProjectPreExecute *DefaultProjectPreExecutor
	Webhooks          webhooks.Sender
}

type Command struct {
	Name        CommandName
	Environment string
	Verbose     bool
	Flags       []string
}

type CommandContext struct {
	// BaseRepo is the repository that the pull request will be merged into.
	BaseRepo models.Repo
	// HeadRepo is the repository that is getting merged into the BaseRepo.
	// If the pull request branch is from the same repository then HeadRepo will
	// be the same as BaseRepo.
	// See https://help.github.com/articles/about-pull-request-merges/.
	HeadRepo models.Repo
	Pull     models.PullRequest
	// User is the user that triggered this command.
	User    models.User
	Command *Command
	Log     *logging.SimpleLogger
	// VCSHost is the host that the command came from.
	VCSHost vcs.Host
}

type CommandHandler struct {
	PlanExecutor             Executor
	ApplyExecutor            Executor
	HelpExecutor             Executor
	LockURLGenerator         LockURLGenerator
	VCSClient                vcs.ClientProxy
	GithubPullGetter         GithubPullGetter
	GitlabMergeRequestGetter GitlabMergeRequestGetter
	CommitStatusUpdater      CommitStatusUpdater
	EventParser              EventParsing
	WorkspaceLocker          WorkspaceLocker
	MarkdownRenderer         *MarkdownRenderer
	Logger                   logging.SimpleLogging
}

type CommandName int

type CommandResponse struct {
	Error          error
	Failure        string
	ProjectResults []ProjectResult
}

type CommandRunner interface {
	// ExecuteCommand is the first step after a command request has been parsed.
	// It handles gathering additional information needed to execute the command
	// and then calling the appropriate services to finish executing the command.
	ExecuteCommand(baseRepo models.Repo, headRepo models.Repo, user models.User, pullNum int, cmd *Command, vcsHost vcs.Host)
}

type CommitStatusUpdater interface {
	// Update updates the status of the head commit of pull.
	Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, cmd *Command, host vcs.Host) error
	// UpdateProjectResult updates the status of the head commit given the
	// state of response.
	UpdateProjectResult(ctx *CommandContext, res CommandResponse) error
}

type CommonData struct {
	Command string
	Verbose bool
	Log     string
}

type DefaultCommitStatusUpdater struct {
	Client vcs.ClientProxy
}

type DefaultProjectFinder struct{}

type DefaultProjectPreExecutor struct {
	Locker       locking.Locker
	ConfigReader ProjectConfigReader
	Terraform    terraform.Runner
	Run          run.Runner
}

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

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

type EnvLocker interface {
	TryLock(repoFullName string, env string, pullNum int) bool
	Unlock(repoFullName, env string, pullNum int)
}

type ErrData struct {
	Error string
	CommonData
}

type EventParser struct {
	GithubUser  string
	GithubToken string
	GitlabUser  string
	GitlabToken string
}

type EventParsing interface {
	DetermineCommand(comment string, vcsHost vcs.Host) (*Command, error)
	ParseGithubIssueCommentEvent(comment *github.IssueCommentEvent) (baseRepo models.Repo, user models.User, pullNum int, err error)
	ParseGithubPull(pull *github.PullRequest) (models.PullRequest, models.Repo, error)
	ParseGithubRepo(ghRepo *github.Repository) (models.Repo, error)
	ParseGitlabMergeEvent(event gitlab.MergeEvent) (models.PullRequest, models.Repo)
	ParseGitlabMergeCommentEvent(event gitlab.MergeCommentEvent) (baseRepo models.Repo, headRepo models.Repo, user models.User)
	ParseGitlabMergeRequest(mr *gitlab.MergeRequest) models.PullRequest
}

type Executor interface {
	Execute(ctx *CommandContext) CommandResponse
}

type FailureData struct {
	Failure string
	CommonData
}

type FileWorkspace struct {
	DataDir string
}

type GithubPullGetter interface {
	// GetPullRequest gets the pull request with id pullNum for the repo.
	GetPullRequest(repo models.Repo, pullNum int) (*github.PullRequest, error)
}

type GitlabMergeRequestGetter interface {
	// GetMergeRequest gets the pull request with the id pullNum for the repo.
	GetMergeRequest(repoFullName string, pullNum int) (*gitlab.MergeRequest, error)
}

type HelpExecutor struct{}

type Hook struct {
	Commands []string `yaml:"commands"`
}

type LockURLGenerator interface {
	// SetLockURL takes a function that given a lock id, will return a url
	// to view that lock.
	SetLockURL(func(id string) (url string))
}

type MarkdownRenderer struct{}

type PlanExecutor struct {
	VCSClient         vcs.ClientProxy
	Terraform         terraform.Runner
	Locker            locking.Locker
	LockURL           func(id string) (url string)
	Run               run.Runner
	Workspace         Workspace
	ProjectPreExecute ProjectPreExecutor
	ProjectFinder     ProjectFinder
}

type PlanSuccess struct {
	TerraformOutput string
	LockURL         string
}

type PreExecuteResult struct {
	ProjectResult    ProjectResult
	ProjectConfig    ProjectConfig
	TerraformVersion *version.Version
	LockResponse     locking.TryLockResponse
}

type ProjectConfig struct {
	// PreInit is a slice of command strings to run prior to terraform init.
	PreInit []string
	// PreGet is a slice of command strings to run prior to terraform get.
	PreGet []string
	// PrePlan is a slice of command strings to run prior to terraform plan.
	PrePlan []string
	// PostPlan is a slice of command strings to run after terraform plan.
	PostPlan []string
	// PreApply is a slice of command strings to run prior to terraform apply.
	PreApply []string
	// PostApply is a slice of command strings to run after terraform apply.
	PostApply []string
	// TerraformVersion is the version specified in the config file or nil
	// if version wasn't specified.
	TerraformVersion *version.Version
	// contains filtered or unexported fields
}

type ProjectConfigManager struct{}

type ProjectConfigReader interface {
	// Exists returns true if a project config file exists at projectPath.
	Exists(projectPath string) bool
	// Read attempts to read the project config file for the project at projectPath.
	// NOTE: projectPath is not the path to the actual config file, just to the
	// project root.
	// Returns the parsed ProjectConfig or error if unable to read.
	Read(projectPath string) (ProjectConfig, error)
}

type ProjectFinder interface {
	// FindModified returns the list of projects that were modified based on
	// the modifiedFiles. The list will be de-duplicated.
	FindModified(log *logging.SimpleLogger, modifiedFiles []string, repoFullName string) []models.Project
}

type ProjectPreExecutor interface {
	// Execute executes the pre plan/apply tasks.
	Execute(ctx *CommandContext, repoDir string, project models.Project) PreExecuteResult
}

type ProjectResult struct {
	Path         string
	Error        error
	Failure      string
	PlanSuccess  *PlanSuccess
	ApplySuccess string
}

type PullCleaner interface {
	// CleanUpPull deletes the workspaces used by the pull request on disk
	// and deletes any locks associated with this pull request for all envs.
	CleanUpPull(repo models.Repo, pull models.PullRequest, host vcs.Host) error
}

type PullClosedExecutor struct {
	Locker    locking.Locker
	VCSClient vcs.ClientProxy
	Workspace Workspace
}

type ResultData struct {
	Results map[string]string
	CommonData
}

type Workspace interface {
	// Clone git clones headRepo, checks out the branch and then returns the
	// absolute path to the root of the cloned repo.
	Clone(log *logging.SimpleLogger, baseRepo models.Repo, headRepo models.Repo, p models.PullRequest, env string) (string, error)
	// GetWorkspace returns the path to the workspace for this repo and pull.
	GetWorkspace(r models.Repo, p models.PullRequest, env string) (string, error)
	// Delete deletes the workspace for this repo and pull.
	Delete(r models.Repo, p models.PullRequest) error
}

type WorkspaceLocker interface {
	// TryLock tries to acquire a lock for this repo, env and pull.
	TryLock(repoFullName string, env string, pullNum int) bool
	// Unlock deletes the lock for this repo, env and pull. If there was no
	// lock it will do nothing.
	Unlock(repoFullName, env string, pullNum int)
}