campaigns

type CampaignSpec struct {
	Name              string                `json:"name,omitempty" yaml:"name"`
	Description       string                `json:"description,omitempty" yaml:"description"`
	On                []OnQueryOrRepository `json:"on,omitempty" yaml:"on"`
	Steps             []Step                `json:"steps,omitempty" yaml:"steps"`
	TransformChanges  *TransformChanges     `json:"transformChanges,omitempty" yaml:"transformChanges,omitempty"`
	ImportChangesets  []ImportChangeset     `json:"importChangesets,omitempty" yaml:"importChangesets"`
	ChangesetTemplate *ChangesetTemplate    `json:"changesetTemplate,omitempty" yaml:"changesetTemplate"`
}

type CampaignSpecID string

type ChangesetSpec struct {
	BaseRepository string `json:"baseRepository"`

	*ExternalChangeset
	*CreatedChangeset
}

type ChangesetSpecID string

type ChangesetTemplate struct {
	Title     string                       `json:"title,omitempty" yaml:"title"`
	Body      string                       `json:"body,omitempty" yaml:"body"`
	Branch    string                       `json:"branch,omitempty" yaml:"branch"`
	Commit    ExpandedGitCommitDescription `json:"commit,omitempty" yaml:"commit"`
	Published overridable.BoolOrString     `json:"published" yaml:"published"`
}

type ChangesetTemplateContext struct {
	// Steps are the changes made by all steps that were executed.
	Steps *StepChanges

	// Outputs are the outputs defined and initialized by the steps.
	Outputs map[string]interface{}

	// Repository is the repository in which the steps were executed.
	Repository graphql.Repository
}

type CreatedChangeset struct {
	BaseRef        string                 `json:"baseRef"`
	BaseRev        string                 `json:"baseRev"`
	HeadRepository string                 `json:"headRepository"`
	HeadRef        string                 `json:"headRef"`
	Title          string                 `json:"title"`
	Body           string                 `json:"body"`
	Commits        []GitCommitDescription `json:"commits"`
	Published      interface{}            `json:"published"`
}

type ExecutionCache interface {
	Get(ctx context.Context, key ExecutionCacheKey) (result ExecutionResult, found bool, err error)
	Set(ctx context.Context, key ExecutionCacheKey, result ExecutionResult) error
	Clear(ctx context.Context, key ExecutionCacheKey) error
}

type ExecutionCacheKey struct {
	*Task
}

type ExecutionDiskCache struct {
	Dir string
}

type ExecutionNoOpCache struct{}

type ExecutionResult struct {
	// Diff is the produced by executing all steps.
	Diff string `json:"diff"`

	// ChangedFiles are files that have been changed by all steps.
	ChangedFiles *StepChanges `json:"changedFiles"`

	// Outputs are the outputs produced by all steps.
	Outputs map[string]interface{} `json:"outputs"`
}

type Executor interface {
	AddTask(repo *graphql.Repository, steps []Step, transform *TransformChanges, template *ChangesetTemplate)
	LogFiles() []string
	Start(ctx context.Context)
	Wait() ([]*ChangesetSpec, error)

	// LockedTaskStatuses calls the given function with the current state of
	// the task statuses. Before calling the function, the statuses are locked
	// to provide a consistent view of all statuses, but that also means the
	// callback should be as fast as possible.
	LockedTaskStatuses(func([]*TaskStatus))
}

type ExecutorOpts struct {
	Cache       ExecutionCache
	Creator     WorkspaceCreator
	Parallelism int
	RepoFetcher RepoFetcher
	Timeout     time.Duration

	ClearCache bool
	KeepLogs   bool
	TempDir    string
	CacheDir   string
}

type ExpandedGitCommitDescription struct {
	Message string           `json:"message,omitempty" yaml:"message"`
	Author  *GitCommitAuthor `json:"author,omitempty" yaml:"author"`
}

type ExternalChangeset struct {
	ExternalID string `json:"externalID"`
}

type GitCommitAuthor struct {
	Name  string `json:"name" yaml:"name"`
	Email string `json:"email" yaml:"email"`
}

type GitCommitDescription struct {
	Message     string `json:"message"`
	Diff        string `json:"diff"`
	AuthorName  string `json:"authorName,omitempty"`
	AuthorEmail string `json:"authorEmail,omitempty"`
}

type Group struct {
	Directory  string `json:"directory,omitempty" yaml:"directory"`
	Branch     string `json:"branch,omitempty" yaml:"branch"`
	Repository string `json:"repository,omitempty" yaml:"repository"`
}

type ImportChangeset struct {
	Repository  string        `json:"repository" yaml:"repository"`
	ExternalIDs []interface{} `json:"externalIDs" yaml:"externalIDs"`
}

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

type OnQueryOrRepository struct {
	RepositoriesMatchingQuery string `json:"repositoriesMatchingQuery,omitempty" yaml:"repositoriesMatchingQuery"`
	Repository                string `json:"repository,omitempty" yaml:"repository"`
	Branch                    string `json:"branch,omitempty" yaml:"branch"`
}

type Output struct {
	Value  string `json:"value,omitempty" yaml:"value,omitempty"`
	Format string `json:"format,omitempty" yaml:"format,omitempty"`
}

type Outputs map[string]Output

type RepoFetcher interface {
	// Fetch must retrieve the given repository and return it as a RepoZip.
	// This will generally imply that the file should be written to a temporary
	// location on the filesystem.
	Fetch(context.Context, *graphql.Repository) (RepoZip, error)
}

type RepoZip interface {
	// Close must finalise the downloaded archive. If one or more temporary
	// files were created, they should be deleted here.
	Close() error

	// Path must return the path to the archive on the filesystem.
	Path() string
}

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

type ServiceOpts struct {
	AllowUnsupported bool
	Client           api.Client
	Workspace        string
}

type Step struct {
	Run       string            `json:"run,omitempty" yaml:"run"`
	Container string            `json:"container,omitempty" yaml:"container"`
	Env       env.Environment   `json:"env,omitempty" yaml:"env"`
	Files     map[string]string `json:"files,omitempty" yaml:"files,omitempty"`
	Outputs   Outputs           `json:"outputs,omitempty" yaml:"outputs,omitempty"`
	// contains filtered or unexported fields
}

type StepChanges struct {
	Modified []string `json:"modified"`
	Added    []string `json:"added"`
	Deleted  []string `json:"deleted"`
	Renamed  []string `json:"renamed"`
}

type StepContext struct {
	// Outputs are the outputs set by the current and all previous steps.
	Outputs map[string]interface{}
	// Step is the result of the current step. Empty when evaluating the "run" field
	// but filled when evaluating the "outputs" field.
	Step StepResult
	// PreviousStep is the result of the previous step. Empty when there is no
	// previous step.
	PreviousStep StepResult
	// Repository is the Sourcegraph repository in which the steps are executed.
	Repository graphql.Repository
}

type StepResult struct {

	// Stdout is the output produced by the step on standard out.
	Stdout *bytes.Buffer
	// Stderr is the output produced by the step on standard error.
	Stderr *bytes.Buffer
	// contains filtered or unexported fields
}

type Task struct {
	Repository *graphql.Repository
	Steps      []Step
	Outputs    map[string]interface{}

	Template         *ChangesetTemplate `json:"-"`
	TransformChanges *TransformChanges  `json:"-"`
}

type TaskExecutionErr struct {
	Err        error
	Logfile    string
	Repository string
}

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

type TaskStatus struct {
	RepoName string

	Cached bool

	LogFile    string
	EnqueuedAt time.Time
	StartedAt  time.Time
	FinishedAt time.Time

	// TODO: add current step and progress fields.
	CurrentlyExecuting string

	// ChangesetSpecs are the specs produced by executing the Task in a
	// repository. With the introduction of `transformChanges` to the campaign
	// spec, one Task can produce multiple ChangesetSpecs.
	ChangesetSpecs []*ChangesetSpec
	// Err is set if executing the Task lead to an error.
	Err error
	// contains filtered or unexported fields
}

type TransformChanges struct {
	Group []Group `json:"group,omitempty" yaml:"group"`
}

type UnsupportedRepoSet map[*graphql.Repository]struct{}

type Workspace interface {
	// DockerRunOpts provides the options that should be given to `docker run`
	// in order to use this workspace. Generally, this will be a set of mount
	// options.
	DockerRunOpts(ctx context.Context, target string) ([]string, error)

	// WorkDir allows workspaces to specify the working directory that should be
	// used when running Docker. If no specific working directory is needed,
	// then the function should return nil.
	WorkDir() *string

	// Close is called once, after all steps have been executed and the diff has
	// been calculated and stored outside the workspace. Implementations should
	// delete the workspace when Close is called.
	Close(ctx context.Context) error

	// Changes is called after each step is executed, and should return the
	// cumulative file changes that have occurred since Prepare was called.
	Changes(ctx context.Context) (*StepChanges, error)

	// Diff should return the total diff for the workspace. This may be called
	// multiple times in the life of a workspace.
	Diff(ctx context.Context) ([]byte, error)
}

type WorkspaceCreator interface {
	// Create creates a new workspace for the given repository and ZIP file.
	Create(ctx context.Context, repo *graphql.Repository, zip string) (Workspace, error)
}