CI: move grafana-build into pkg/build (#105640)
* move grafana-build into pkg/build
This commit is contained in:
Kevin Minehart
@@ -0,0 +1,203 @@
|
||||
package artifacts
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"dagger.io/dagger"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/arguments"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/backend"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/docker"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/flags"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/packages"
|
||||
"github.com/grafana/grafana/pkg/build/daggerbuild/pipeline"
|
||||
)
|
||||
|
||||
var (
|
||||
ProDockerArguments = arguments.Join(
|
||||
DebArguments,
|
||||
[]pipeline.Argument{
|
||||
arguments.HGDirectory,
|
||||
arguments.ProDockerRegistry,
|
||||
arguments.ProDockerOrg,
|
||||
arguments.ProDockerRepo,
|
||||
arguments.HGTagFormat,
|
||||
},
|
||||
)
|
||||
ProDockerFlags = flags.JoinFlags(
|
||||
DebFlags,
|
||||
flags.DockerFlags,
|
||||
)
|
||||
)
|
||||
|
||||
var ProDockerInitializer = Initializer{
|
||||
InitializerFunc: NewProDockerFromString,
|
||||
Arguments: ProDockerArguments,
|
||||
}
|
||||
|
||||
// ProDocker uses a built deb installer to create a docker image
|
||||
type ProDocker struct {
|
||||
Name packages.Name
|
||||
Version string
|
||||
BuildID string
|
||||
Distro backend.Distribution
|
||||
ProDir *dagger.Directory
|
||||
|
||||
// ProRegistry is the docker registry when using the `pro` name. (e.g. hub.docker.io)
|
||||
ProRegistry string
|
||||
// ProOrg is the docker org when using the `pro` name. (e.g. grafana)
|
||||
ProOrg string
|
||||
// ProOrg is the docker repo when using the `pro` name. (e.g. grafana-pro)
|
||||
ProRepo string
|
||||
// TagFormat is the docker tag format when using the `pro` name. (e.g. {{ .version }}-{{ .os }}-{{ .arch }})
|
||||
TagFormat string
|
||||
|
||||
// Building the Pro image requires a Debian package instead of a tar.gz
|
||||
Deb *pipeline.Artifact
|
||||
}
|
||||
|
||||
func (d *ProDocker) Dependencies(ctx context.Context) ([]*pipeline.Artifact, error) {
|
||||
return []*pipeline.Artifact{
|
||||
d.Deb,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (d *ProDocker) Builder(ctx context.Context, opts *pipeline.ArtifactContainerOpts) (*dagger.Container, error) {
|
||||
deb, err := opts.Store.File(ctx, d.Deb)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error getting deb from state: %w", err)
|
||||
}
|
||||
|
||||
socket := opts.Client.Host().UnixSocket("/var/run/docker.sock")
|
||||
|
||||
return opts.Client.Container().From("docker").
|
||||
WithUnixSocket("/var/run/docker.sock", socket).
|
||||
WithMountedDirectory("/src", d.ProDir).
|
||||
WithMountedFile("/src/grafana.deb", deb).
|
||||
WithWorkdir("/src"), nil
|
||||
}
|
||||
|
||||
func (d *ProDocker) BuildFile(ctx context.Context, builder *dagger.Container, opts *pipeline.ArtifactContainerOpts) (*dagger.File, error) {
|
||||
tags, err := docker.Tags(d.ProOrg, d.ProRegistry, []string{d.ProRepo}, d.TagFormat, packages.NameOpts{
|
||||
Name: d.Name,
|
||||
Version: d.Version,
|
||||
BuildID: d.BuildID,
|
||||
Distro: d.Distro,
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
builder = docker.Build(opts.Client, builder, &docker.BuildOpts{
|
||||
Dockerfile: "./docker/hosted-grafana-all/Dockerfile",
|
||||
Tags: tags,
|
||||
Target: "hosted-grafana-localpro",
|
||||
Platform: dagger.Platform("linux/amd64"),
|
||||
BuildArgs: []string{
|
||||
"RELEASE_TYPE=main",
|
||||
// I think because deb files use a ~ as a version delimiter of some kind, so the hg docker image uses that instead of a -
|
||||
fmt.Sprintf("GRAFANA_VERSION=%s", strings.Replace(d.Version, "-", "~", 1)),
|
||||
},
|
||||
})
|
||||
|
||||
// Save the resulting docker image to the local filesystem
|
||||
return builder.WithExec([]string{"docker", "save", tags[0], "-o", "pro.tar"}).File("pro.tar"), nil
|
||||
}
|
||||
|
||||
func (d *ProDocker) BuildDir(ctx context.Context, builder *dagger.Container, opts *pipeline.ArtifactContainerOpts) (*dagger.Directory, error) {
|
||||
panic("This artifact does not produce directories")
|
||||
}
|
||||
|
||||
func (d *ProDocker) Publisher(ctx context.Context, opts *pipeline.ArtifactContainerOpts) (*dagger.Container, error) {
|
||||
panic("not implemented")
|
||||
}
|
||||
|
||||
func (d *ProDocker) PublishFile(ctx context.Context, opts *pipeline.ArtifactPublishFileOpts) error {
|
||||
panic("not implemented")
|
||||
}
|
||||
|
||||
func (d *ProDocker) PublishDir(ctx context.Context, opts *pipeline.ArtifactPublishDirOpts) error {
|
||||
panic("This artifact does not produce directories")
|
||||
}
|
||||
|
||||
// Filename should return a deterministic file or folder name that this build will produce.
|
||||
// This filename is used as a map key for caching, so implementers need to ensure that arguments or flags that affect the output
|
||||
// also affect the filename to ensure that there are no collisions.
|
||||
// For example, the backend for `linux/amd64` and `linux/arm64` should not both produce a `bin` folder, they should produce a
|
||||
// `bin/linux-amd64` folder and a `bin/linux-arm64` folder. Callers can mount this as `bin` or whatever if they want.
|
||||
func (d *ProDocker) Filename(ctx context.Context) (string, error) {
|
||||
ext := "docker-pro.tar.gz"
|
||||
|
||||
return packages.FileName(d.Name, d.Version, d.BuildID, d.Distro, ext)
|
||||
}
|
||||
|
||||
func (d *ProDocker) VerifyFile(ctx context.Context, client *dagger.Client, file *dagger.File) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *ProDocker) VerifyDirectory(ctx context.Context, client *dagger.Client, dir *dagger.Directory) error {
|
||||
panic("not implemented") // TODO: Implement
|
||||
}
|
||||
|
||||
func NewProDockerFromString(ctx context.Context, log *slog.Logger, artifact string, state pipeline.StateHandler) (*pipeline.Artifact, error) {
|
||||
options, err := pipeline.ParseFlags(artifact, DockerFlags)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p, err := GetPackageDetails(ctx, options, state)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
deb, err := NewDebFromString(ctx, log, artifact, state)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
proRegistry, err := state.String(ctx, arguments.ProDockerRegistry)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
proOrg, err := state.String(ctx, arguments.ProDockerOrg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
proRepo, err := state.String(ctx, arguments.ProDockerRepo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
tagFormat, err := state.String(ctx, arguments.HGTagFormat)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
dir, err := state.Directory(ctx, arguments.HGDirectory)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
log.Info("initializing Pro Docker artifact", "Org", proOrg, "registry", proRegistry, "repo", proRepo, "tag", tagFormat)
|
||||
|
||||
return pipeline.ArtifactWithLogging(ctx, log, &pipeline.Artifact{
|
||||
ArtifactString: artifact,
|
||||
Handler: &ProDocker{
|
||||
Name: p.Name,
|
||||
Version: p.Version,
|
||||
BuildID: p.BuildID,
|
||||
Distro: p.Distribution,
|
||||
ProDir: dir,
|
||||
Deb: deb,
|
||||
|
||||
ProRegistry: proRegistry,
|
||||
ProOrg: proOrg,
|
||||
ProRepo: proRepo,
|
||||
TagFormat: tagFormat,
|
||||
},
|
||||
Type: pipeline.ArtifactTypeFile,
|
||||
Flags: DockerFlags,
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user