debug

Author: danielm-codefresh

Dockerfile

@@ -2,22 +2,14 @@ ARG GO_VERSION=1.17-alpine
 ARG GOLANGCI_LINT_VERSION=v1.40.1-alpine
 ARG PROTOC_GEN_GO_VERSION=v1.4.3
 
-ARG BUILD_TAGS="e2e,kube"
-ARG DOCS_FORMATS="md,yaml"
-ARG LICENSE_FILES=".*\(Dockerfile\|Makefile\|\.go\|\.hcl\|\.sh\)"
-
 FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION} AS base
-RUN apk add --no-cache \
-      docker \
-      file \
-      git \
-      make \
-      protoc \
-      protobuf-dev
-WORKDIR /src
-ENV CGO_ENABLED=0
-
-FROM base AS build-base
+WORKDIR /compose-cli
+RUN apk add --no-cache -vv \
+    git \
+    docker \
+    make \
+    protoc \
+    protobuf-dev
 COPY go.* .
 RUN --mount=type=cache,target=/go/pkg/mod \
     --mount=type=cache,target=/root/.cache/go-build \
@@ -27,13 +19,16 @@ FROM base AS make-compose-plugin
 ENV CGO_ENABLED=0
 ARG TARGETOS
 ARG TARGETARCH
-ARG TARGETVARIANT
-RUN --mount=from=binary \
-    mkdir -p /out && \
-    # TODO: should just use standard arch
-    TARGETARCH=$([ "$TARGETARCH" = "amd64" ] && echo "x86_64" || echo "$TARGETARCH"); \
-    TARGETARCH=$([ "$TARGETARCH" = "arm64" ] && echo "aarch64" || echo "$TARGETARCH"); \
-    cp docker-compose* "/out/docker-compose-${TARGETOS}-${TARGETARCH}${TARGETVARIANT}$(ls docker-compose* | sed -e 's/^docker-compose//')"
+ARG BUILD_TAGS
+ARG GIT_TAG
+RUN --mount=target=. \
+    --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    GOOS=${TARGETOS} \
+    GOARCH=${TARGETARCH} \
+    BUILD_TAGS=${BUILD_TAGS} \
+    GIT_TAG=${GIT_TAG} \
+    make COMPOSE_BINARY=/out/docker-compose -f builder.Makefile compose-plugin
 
 FROM debian:bullseye-slim AS compose-plugin
 WORKDIR /root

Makefile

@@ -12,129 +12,112 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-PKG := github.com/docker/compose/v2
-VERSION ?= $(shell git describe --match 'v[0-9]*' --dirty='.m' --always --tags)
+export DOCKER_BUILDKIT=1
 
-GO_LDFLAGS ?= -s -w -X ${PKG}/internal.Version=${VERSION}
-GO_BUILDTAGS ?= e2e,kube
-
-ifeq ($(OS),Windows_NT)
-    DETECTED_OS = Windows
-else
-    DETECTED_OS = $(shell uname -s)
-endif
-ifeq ($(DETECTED_OS),Linux)
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Linux)
 	MOBY_DOCKER=/usr/bin/docker
 endif
-ifeq ($(DETECTED_OS),Darwin)
+ifeq ($(UNAME_S),Darwin)
 	MOBY_DOCKER=/Applications/Docker.app/Contents/Resources/bin/docker
 endif
-ifeq ($(DETECTED_OS),Windows)
-	BINARY_EXT=.exe
-endif
 
-TEST_COVERAGE_FLAGS = -race -coverprofile=coverage.out -covermode=atomic
-TEST_FLAGS?= -timeout 15m
+BINARY_FOLDER=$(shell pwd)/bin
+GIT_TAG?=$(shell git describe --tags --match "v[0-9]*")
+TEST_FLAGS?=
 E2E_TEST?=
 ifeq ($(E2E_TEST),)
 else
 	TEST_FLAGS=-run $(E2E_TEST)
 endif
 
-BUILDX_CMD ?= docker buildx
-DESTDIR ?= ./bin/build
-
-all: build
+all: compose-plugin
 
-.PHONY: build ## Build the compose cli-plugin
-build:
-	CGO_ENABLED=0 GO111MODULE=on go build -trimpath -tags "$(GO_BUILDTAGS)" -ldflags "$(GO_LDFLAGS)" -o "$(DESTDIR)/docker-compose$(BINARY_EXT)" ./cmd
-
-.PHONY: binary
-binary:
-	$(BUILDX_CMD) bake binary
-
-.PHONY: install
-install: binary
-	mkdir -p ~/.docker/cli-plugins
-	install bin/build/docker-compose ~/.docker/cli-plugins/docker-compose
+.PHONY: compose-plugin
+compose-plugin: ## Compile the compose cli-plugin
+	@docker build . --target compose-plugin \
+	--platform local \
+	--build-arg BUILD_TAGS=e2e,kube \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--output ./bin
 
 .PHONY: e2e-compose
 e2e-compose: ## Run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
-	docker compose version
-	go test $(TEST_FLAGS) $(TEST_COVERAGE_FLAGS) -count=1 ./pkg/e2e
+	go test $(TEST_FLAGS) -count=1 ./pkg/e2e
 
 .PHONY: e2e-compose-standalone
 e2e-compose-standalone: ## Run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
-	docker-compose version
-	go test $(TEST_FLAGS) -v -count=1 -parallel=1 --tags=standalone ./pkg/e2e
-
-.PHONY: build-and-e2e-compose
-build-and-e2e-compose: build e2e-compose ## Compile the compose cli-plugin and run end to end local tests in plugin mode. Set E2E_TEST=TestName to run a single test
-
-.PHONY: build-and-e2e-compose-standalone
-build-and-e2e-compose-standalone: build e2e-compose-standalone ## Compile the compose cli-plugin and run End to end local tests in standalone mode. Set E2E_TEST=TestName to run a single test
+	go test $(TEST_FLAGS) -count=1 --tags=standalone ./pkg/e2e
 
 .PHONY: mocks
 mocks:
-	mockgen --version >/dev/null 2>&1 || go install github.com/golang/mock/[email protected]
 	mockgen -destination pkg/mocks/mock_docker_cli.go -package mocks github.com/docker/cli/cli/command Cli
 	mockgen -destination pkg/mocks/mock_docker_api.go -package mocks github.com/docker/docker/client APIClient
-	mockgen -destination pkg/mocks/mock_docker_compose_api.go -package mocks -source=./pkg/api/api.go Service
 
 .PHONY: e2e
 e2e: e2e-compose e2e-compose-standalone ## Run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
 
-.PHONY: build-and-e2e
-build-and-e2e: build e2e-compose e2e-compose-standalone ## Compile the compose cli-plugin and run end to end local tests in both modes. Set E2E_TEST=TestName to run a single test
-
 .PHONY: cross
 cross: ## Compile the CLI for linux, darwin and windows
-	$(BUILDX_CMD) bake binary-cross
+	@docker build . --target cross \
+	--build-arg BUILD_TAGS \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--output ./bin \
 
 .PHONY: test
 test: ## Run unit tests
-	$(BUILDX_CMD) bake test
+	@docker build --progress=plain . \
+	--build-arg BUILD_TAGS=kube \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--target test
 
 .PHONY: cache-clear
 cache-clear: ## Clear the builder cache
-	$(BUILDX_CMD) prune --force --filter type=exec.cachemount --filter=unused-for=24h
+	@docker builder prune --force --filter type=exec.cachemount --filter=unused-for=24h
 
 .PHONY: lint
 lint: ## run linter(s)
-	$(BUILDX_CMD) bake lint
+	@docker build . \
+	--build-arg BUILD_TAGS=kube,e2e \
+	--build-arg GIT_TAG=$(GIT_TAG) \
+	--target lint
 
 .PHONY: docs
 docs: ## generate documentation
-	$(eval $@_TMP_OUT := $(shell mktemp -d -t compose-output.XXXXXXXXXX))
-	$(BUILDX_CMD) bake --set "*.output=type=local,dest=$($@_TMP_OUT)" docs-update
+	$(eval $@_TMP_OUT := $(shell mktemp -d -t dockercli-output.XXXXXXXXXX))
+	docker build . \
+	--output type=local,dest=$($@_TMP_OUT) \
+	-f ./docs/docs.Dockerfile \
+	--target update
 	rm -rf ./docs/internal
 	cp -R "$($@_TMP_OUT)"/out/* ./docs/
 	rm -rf "$($@_TMP_OUT)"/*
 
 .PHONY: validate-docs
 validate-docs: ## validate the doc does not change
-	$(BUILDX_CMD) bake docs-validate
+	@docker build . \
+	-f ./docs/docs.Dockerfile \
+	--target validate
 
 .PHONY: check-dependencies
 check-dependencies: ## check dependency updates
 	go list -u -m -f '{{if not .Indirect}}{{if .Update}}{{.}}{{end}}{{end}}' all
 
 .PHONY: validate-headers
 validate-headers: ## Check license header for all files
-	$(BUILDX_CMD) bake license-validate
+	@docker build . --target check-license-headers
 
 .PHONY: go-mod-tidy
 go-mod-tidy: ## Run go mod tidy in a container and output resulting go.mod and go.sum
-	$(BUILDX_CMD) bake vendor-update
+	@docker build . --target go-mod-tidy --output .
 
 .PHONY: validate-go-mod
 validate-go-mod: ## Validate go.mod and go.sum are up-to-date
-	$(BUILDX_CMD) bake vendor-validate
+	@docker build . --target check-go-mod
 
-validate: validate-go-mod validate-headers validate-docs  ## Validate sources
+validate: validate-go-mod validate-headers validate-docs ## Validate sources
 
-pre-commit: validate check-dependencies lint build test e2e-compose
+pre-commit: validate check-dependencies lint compose-plugin test e2e-compose
 
 help: ## Show help
 	@echo Please specify a build target. The choices are: