events

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

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

type CommandContext struct {
	BaseRepo models.Repo
	HeadRepo models.Repo
	Pull     models.PullRequest
	User     models.User
	Command  *Command
	Log      *logging.SimpleLogger
	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
	EnvLocker                EnvLocker
	MarkdownRenderer         *MarkdownRenderer
	Logger                   logging.SimpleLogging
}

type CommandName int

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

type CommandRunner interface {
	ExecuteCommand(baseRepo models.Repo, headRepo models.Repo, user models.User, pullNum int, cmd *Command, vcsHost vcs.Host)
}

type CommitStatusUpdater interface {
	Update(repo models.Repo, pull models.PullRequest, status vcs.CommitStatus, cmd *Command, host vcs.Host) error
	UpdateProjectResult(ctx *CommandContext, res CommandResponse) error
}

type CommonData struct {
	Command string
	Verbose bool
	Log     string
}

type DefaultCommitStatusUpdater struct {
	Client vcs.ClientProxy
}

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(repo models.Repo, pullNum int) (*github.PullRequest, error)
}

type GitlabMergeRequestGetter interface {
	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 ModifiedProjectFinder 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 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     ModifiedProjectFinder
}

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.
	// Returns the parsed ProjectConfig or error if unable to read.
	Read(projectPath string) (ProjectConfig, error)
}

type ProjectFinder struct{}

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

type ProjectPreExecutor interface {
	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(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(r models.Repo, p models.PullRequest, env string) (string, error)
	Delete(r models.Repo, p models.PullRequest) error
}