Implement QuickSyncPlan for k8s plugin

pkg/app/pipedv1/plugin/platform/kubernetes/planner/server.go

@@ -17,17 +17,27 @@ package planner
 import (
 	"context"
 	"fmt"
+	"io"
+	"os"
+	"time"
 
+	"github.com/pipe-cd/pipecd/pkg/app/pipedv1/deploysource"
+	"github.com/pipe-cd/pipecd/pkg/app/pipedv1/plugin/sourcecloner"
 	"github.com/pipe-cd/pipecd/pkg/plugin/api/v1alpha1/platform"
 	"github.com/pipe-cd/pipecd/pkg/regexpool"
 
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 )
 
+type secretDecrypter interface {
+	Decrypt(string) (string, error)
+}
+
 type PlannerService struct {
 	platform.UnimplementedPlannerServiceServer
 
+	Decrypter secretDecrypter
 	RegexPool *regexpool.Pool
 	Logger    *zap.Logger
 }
@@ -38,8 +48,12 @@ func (a *PlannerService) Register(server *grpc.Server) {
 }
 
 // NewPlannerService creates a new planService.
-func NewPlannerService(logger *zap.Logger) *PlannerService {
+func NewPlannerService(
+	decrypter secretDecrypter,
+	logger *zap.Logger,
+) *PlannerService {
 	return &PlannerService{
+		Decrypter: decrypter,
 		RegexPool: regexpool.DefaultPool(),
 		Logger:    logger.Named("planner"),
 	}
@@ -63,7 +77,43 @@ func (ps *PlannerService) DetermineStrategy(ctx context.Context, in *platform.De
 }
 
 func (ps *PlannerService) QuickSyncPlan(ctx context.Context, in *platform.QuickSyncPlanRequest) (*platform.QuickSyncPlanResponse, error) {
-	return nil, fmt.Errorf("not implemented yet")
+	now := time.Now()
+
+	cloner, err := sourcecloner.NewCloner(
+		in.GetInput().GetSourceRemoteUrl(),
+		in.GetInput().GetDeployment().GetGitPath().GetRepo().GetBranch(),
+		"target",
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create git client (%w)", err)
+	}
+
+	d, err := os.MkdirTemp("", "") // TODO
+	if err != nil {
+		return nil, fmt.Errorf("failed to prepare temporary directory (%w)", err)
+	}
+	defer os.RemoveAll(d)
+
+	p := deploysource.NewProvider(
+		d,
+		cloner,
+		*in.GetInput().GetDeployment().GetGitPath(),
+		ps.Decrypter,
+	)
+
+	ds, err := p.GetReadOnly(ctx, io.Discard /* TODO */)
+	if err != nil {
+		return nil, err
+	}
+
+	autoRollback := false
+	if a := ds.ApplicationConfig.KubernetesApplicationSpec.Input.AutoRollback; a != nil {
+		autoRollback = *a
+	}
+
+	return &platform.QuickSyncPlanResponse{
+		Stages: buildQuickSyncPipeline(autoRollback, now),
+	}, nil
 }
 
 func (ps *PlannerService) PipelineSyncPlan(ctx context.Context, in *platform.PipelineSyncPlanRequest) (*platform.PipelineSyncPlanResponse, error) {

pkg/app/pipedv1/plugin/secrets/decrypter.go

@@ -0,0 +1,34 @@
+// Copyright 2024 The PipeCD Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package secrets
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pipe-cd/pipecd/pkg/app/pipedv1/cmd/piped/service"
+)
+
+type Decrypter struct {
+	client service.PluginServiceClient
+}
+
+func (d *Decrypter) Decrypt(src string) (string, error) {
+	r, err := d.client.DecryptSecret(context.TODO(), &service.DecryptSecretRequest{Secret: src})
+	if err != nil {
+		return "", fmt.Errorf("failed to decrypt secret: %w", err)
+	}
+	return r.GetDecryptedSecret(), nil
+}

pkg/app/pipedv1/plugin/sourcecloner/cloner.go

@@ -0,0 +1,82 @@
+// Copyright 2024 The PipeCD Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sourcecloner
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"sync"
+
+	"github.com/pipe-cd/pipecd/pkg/app/piped/deploysource"
+	"github.com/pipe-cd/pipecd/pkg/git"
+)
+
+var _ deploysource.SourceCloner = (*Cloner)(nil)
+
+var gitPath = sync.OnceValues(func() (string, error) {
+	path, err := exec.LookPath("git")
+	if err != nil {
+		return "", err
+	}
+	return path, nil
+})
+
+// Cloner is a source cloner for git repositories.
+type Cloner struct {
+	gitPath      string
+	remotePath   string
+	revision     string
+	revisionName string
+}
+
+// NewCloner creates a new Cloner instance.
+// if revision is empty, it will checkout defualt branch.
+func NewCloner(remotePath, revision, revisionName string) (*Cloner, error) {
+	gitPath, err := gitPath()
+	if err != nil {
+		return nil, err
+	}
+
+	return &Cloner{
+		gitPath:      gitPath,
+		remotePath:   remotePath,
+		revision:     revision,
+		revisionName: revisionName,
+	}, nil
+}
+
+// Clone implements deploysource.SourceCloner.
+func (c *Cloner) Clone(ctx context.Context, dest string) error {
+	if _, err := git.RunGitCommand(ctx, c.gitPath, "", os.Environ(), "clone", c.remotePath, dest); err != nil {
+		return err
+	}
+	if c.revision == "" {
+		if _, err := git.RunGitCommand(ctx, c.gitPath, "", os.Environ(), "-C", dest, "checkout", c.revision); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Revision implements deploysource.SourceCloner.
+func (c *Cloner) Revision() string {
+	return c.revision
+}
+
+// RevisionName implements deploysource.SourceCloner.
+func (c *Cloner) RevisionName() string {
+	return c.revisionName
+}

pkg/git/client.go

@@ -252,6 +252,11 @@ func (c *client) envsForRepo(remote string) []string {
 	return append(envs, c.gitEnvs...)
 }
 
+// RunGitCommand runs a git command with the given arguments.
+func RunGitCommand(ctx context.Context, execPath, dir string, envs []string, args ...string) ([]byte, error) {
+	return runGitCommand(ctx, execPath, dir, envs, args...)
+}
+
 func runGitCommand(ctx context.Context, execPath, dir string, envs []string, args ...string) ([]byte, error) {
 	cmd := exec.CommandContext(ctx, execPath, args...)
 	cmd.Dir = dir