models

Documentation

Index

• type Artifacts
  • func (a *Artifacts) UnmarshalYAML(node *yaml.Node) error
• type Aws
• type BuildPipelines
• type Caches
• type Clone
• type CustomStepVariable
  • func (v *CustomStepVariable) UnmarshalYAML(node *yaml.Node) error
• type Definitions
• type EnvironmentVariablesRef
  • func (e *EnvironmentVariablesRef) UnmarshalYAML(node *yaml.Node) error
• type ExecutionUnit
• type ExecutionUnitRef
  • func (s *ExecutionUnitRef) UnmarshalYAML(node *yaml.Node) error
• type GlobalSettings
• type Image
  • func (i *Image) UnmarshalYAML(node *yaml.Node) error
• type ImageData
• type ParallelSteps
  • func (ps *ParallelSteps) UnmarshalYAML(node *yaml.Node) error
• type Pipe
  • func (p *Pipe) UnmarshalYAML(node *yaml.Node) error
• type PipeToExecute
• type Pipeline
• type Script
  • func (s *Script) UnmarshalYAML(value *yaml.Node) error
• type Service
• type SharedStepFiles
• type Size
• type Step
  • func (s *Step) UnmarshalYAML(node *yaml.Node) error
• type StepMap
  • func (sm *StepMap) UnmarshalYAML(node *yaml.Node) error
• type StepTriggerType

Types

type Artifacts

type Artifacts struct {
	SharedStepFiles *SharedStepFiles
	Paths           []*string
}

func (*Artifacts) UnmarshalYAML

func (a *Artifacts) UnmarshalYAML(node *yaml.Node) error

type Aws

type Aws struct {
	AccessKey *string `yaml:"access-key"` // AWS Access Key
	SecretKey *string `yaml:"secret-key"` // AWS Secret Key
}

type BuildPipelines

type BuildPipelines struct {
	Default      []*Step  `yaml:"default"`                 // The default pipeline runs on every push to the repository, unless a branch-specific; pipeline is defined.; You can define a branch pipeline in the branches section.; ; Note: The default pipeline doesn't run on tags or bookmarks.
	Branches     *StepMap `yaml:"branches,omitempty"`      // Defines a section for all branch-specific build pipelines. The names or expressions in; this section are matched against:; ; * branches in your Git repository; * named branches in your Mercurial repository; ; You can use glob patterns for handling the branch names.
	Tags         *StepMap `yaml:"tags,omitempty"`          // Defines all tag-specific build pipelines.; ; The names or expressions in this section are matched against tags and annotated tags in; your Git repository.; ; You can use glob patterns for handling the tag names.
	Bookmarks    *StepMap `yaml:"bookmarks,omitempty"`     // Defines all bookmark-specific build pipelines.; ; The names or expressions in this section are matched against bookmarks in your Mercurial; repository.; ; You can use glob patterns for handling the tag names.
	PullRequests *StepMap `yaml:"pull-requests,omitempty"` // A special pipeline which only runs on pull requests. Pull-requests has the same level of; indentation as branches.; ; This type of pipeline runs a little differently to other pipelines. When it's triggered,; we'll merge the destination branch into your working branch before it runs. If the merge; fails we will stop the pipeline.
	Custom       *StepMap `yaml:"custom,omitempty"`        // Defines pipelines that can only be triggered manually or scheduled from the Bitbucket; Cloud interface.
}

type Caches

type Caches map[string]*string

type Clone

type Clone struct {
	Depth   any   `yaml:"depth"`             // Depth of Git clones for all pipelines (supported only for Git repositories)
	Enabled *bool `yaml:"enabled,omitempty"` // Enables cloning of the repository
	LFS     *bool `yaml:"lfs,omitempty"`     // Enables the download of LFS files in the clone (supported only for Git repositories)
}

type CustomStepVariable

type CustomStepVariable struct {
	Name          *string   `yaml:"name,omitempty"` // Name of a variable for the custom pipeline
	Default       *string   `yaml:"default,omitempty"`
	AllowedValues []*string `yaml:"allowed-values,omitempty"`
	FileReference *models.FileReference
}

func (*CustomStepVariable) UnmarshalYAML

func (v *CustomStepVariable) UnmarshalYAML(node *yaml.Node) error

type Definitions

type Definitions struct {
	Caches   *Caches             `yaml:"caches,omitempty"`
	Services map[string]*Service `yaml:"services,omitempty"`
	Steps    []*Step             `yaml:"steps,omitempty"`
}

type EnvironmentVariablesRef

type EnvironmentVariablesRef struct {
	models.EnvironmentVariables
	FileReference *models.FileReference
}

func (*EnvironmentVariablesRef) UnmarshalYAML

func (e *EnvironmentVariablesRef) UnmarshalYAML(node *yaml.Node) error

type ExecutionUnit

type ExecutionUnit struct {
	AfterScript []*Script        `yaml:"after-script"` // Commands inside an after-script section will run when the step succeeds or fails. This; could be useful for clean up commands, test coverage, notifications, or rollbacks you; might want to run, especially if your after-script uses the value of; BITBUCKET_EXIT_CODE.; ; Note: If any commands in the after-script section fail:; ; * we won't run any more commands in that section; ; * it will not effect the reported status of the step.
	Artifacts   *Artifacts       `yaml:"artifacts"`
	Caches      []*string        `yaml:"caches"` // Caches enabled for the step
	Clone       *Clone           `yaml:"clone,omitempty"`
	Deployment  *string          `yaml:"deployment,omitempty"` // Sets the type of environment for your deployment step, used in the Deployments dashboard.
	Image       *Image           `yaml:"image"`
	MaxTime     *int64           `yaml:"max-time,omitempty"`
	Name        *string          `yaml:"name,omitempty"` // You can add a name to a step to make displays and reports easier to read and understand.
	RunsOn      []*string        `yaml:"runs-on"`        // self-hosted runner labels
	Script      []*Script        `yaml:"script"`         // Commands to execute in the step
	Services    []*string        `yaml:"services"`       // Services enabled for the step
	Size        *Size            `yaml:"size,omitempty"`
	Trigger     *StepTriggerType `yaml:"trigger,omitempty"` // Specifies whether a step will run automatically or only after someone manually triggers; it. You can define the trigger type as manual or automatic. If the trigger type is not; defined, the step defaults to running automatically. The first step cannot be manual. If; you want to have a whole pipeline only run from a manual trigger then use a custom; pipeline.
}

type ExecutionUnitRef

type ExecutionUnitRef struct {
	ExecutionUnit *ExecutionUnit
	FileReference *models.FileReference
}

func (*ExecutionUnitRef) UnmarshalYAML

func (s *ExecutionUnitRef) UnmarshalYAML(node *yaml.Node) error

type GlobalSettings

type GlobalSettings struct {
	Docker  *bool  `yaml:"docker,omitempty"` // A flag to add Docker to all build steps in all pipelines
	MaxTime *int64 `yaml:"max-time,omitempty"`
	Size    *Size  `yaml:"size,omitempty"`
}

type Image

type Image struct {
	ImageData *ImageData
}

func (*Image) UnmarshalYAML

func (i *Image) UnmarshalYAML(node *yaml.Node) error

type ImageData

type ImageData struct {
	Name      *string `yaml:"name"`
	RunAsUser *int64  `yaml:"run-as-user,omitempty"`
	Email     *string `yaml:"email,omitempty"`    // Email to use to fetch the Docker image
	Password  *string `yaml:"password,omitempty"` // Password to use to fetch the Docker image
	Username  *string `yaml:"username,omitempty"` // Username to use to fetch the Docker image
	Aws       *Aws    `yaml:"aws,omitempty"`      // AWS credentials
}

type ParallelSteps

type ParallelSteps struct {
	Step *ExecutionUnitRef `yaml:"step,omitempty"`
}

func (*ParallelSteps) UnmarshalYAML

func (ps *ParallelSteps) UnmarshalYAML(node *yaml.Node) error

type Pipe

type Pipe struct {
	String        *string `yaml:"pipe"` // Pipes make complex tasks easier, by doing a lot of the work behind the scenes.; This means you can just select which pipe you want to use, and supply the necessary; variables.; You can look at the repository for the pipe to see what commands it is running.; ; Learn more about pipes: https://confluence.atlassian.com/bitbucket/pipes-958765631.html
	FileReference *models.FileReference
}

func (*Pipe) UnmarshalYAML

func (p *Pipe) UnmarshalYAML(node *yaml.Node) error

type PipeToExecute

type PipeToExecute struct {
	Pipe      *Pipe
	Variables *EnvironmentVariablesRef `yaml:"variables,omitempty"` // Environment variables passed to the pipe
}

type Pipeline

type Pipeline struct {
	Image       *Image          `yaml:"image"`
	Clone       *Clone          `yaml:"clone,omitempty"`
	Options     *GlobalSettings `yaml:"options,omitempty"`
	Definitions *Definitions    `yaml:"definitions,omitempty"`
	Pipelines   *BuildPipelines `yaml:"pipelines"`
}

type Script

type Script struct {
	PipeToExecute *PipeToExecute
	String        *string
	FileReference *models.FileReference
}

func (*Script) UnmarshalYAML

func (s *Script) UnmarshalYAML(value *yaml.Node) error

type Service

type Service struct {
	Image     *Image                   `yaml:"image"`
	Memory    *int64                   `yaml:"memory,omitempty"`    // Memory limit for the service container, in megabytes
	Variables *EnvironmentVariablesRef `yaml:"variables,omitempty"` // Environment variables passed to the service container
}

type SharedStepFiles

type SharedStepFiles struct {
	Download *bool     `yaml:"download,omitempty"` // Indicates whether to download artifact in the step
	Paths    []*string `yaml:"paths"`
}

type Size

type Size string

const (
	X1 Size = "1x"
	X2 Size = "2x"
)

type Step

type Step struct {
	Step      *ExecutionUnitRef     `yaml:"step,omitempty"`
	Parallel  []*ParallelSteps      `yaml:"parallel"`
	Variables []*CustomStepVariable `yaml:"variables"` // List of variables for the custom pipeline
}

func (*Step) UnmarshalYAML

func (s *Step) UnmarshalYAML(node *yaml.Node) error

type StepMap

type StepMap map[string][]*Step

func (*StepMap) UnmarshalYAML

func (sm *StepMap) UnmarshalYAML(node *yaml.Node) error

type StepTriggerType

type StepTriggerType string

const (
	AUTOMATIC StepTriggerType = "automatic"
	MANUAL    StepTriggerType = "manual"
)