refactor(stack): move transformers from manifest to stack package (#1903)

<!-- Provide summary of changes -->
To avoid a circular dependency and remove `manifest`'s de facto responsibility for the way its structs are used elsewhere, this PR moves all methods of the form:
```go
package manifest

func (s *ManifestStruct) Converter() template.Struct
``` 
to the form
```golang
package stack

func converter(s manifest.ManifestStruct) template.Struct
```

This makes `stack` responsible for the conversion logic and housing default values for fields that can be left unspecified in the manifest.

<!-- Issue number, if available. E.g. "Fixes #31", "Addresses #42, 77" -->

By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.

Author: bvtujo

internal/pkg/deploy/cloudformation/stack/backend_svc.go

@@ -75,11 +75,11 @@ func (s *BackendService) Template() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	sidecars, err := s.manifest.Sidecar.Options()
+	sidecars, err := convertSidecar(s.manifest.Sidecars)
 	if err != nil {
 		return "", fmt.Errorf("convert the sidecar configuration for service %s: %w", s.name, err)
 	}
-	autoscaling, err := s.manifest.Count.Autoscaling.Options()
+	autoscaling, err := convertAutoscaling(&s.manifest.Count.Autoscaling)
 	if err != nil {
 		return "", fmt.Errorf("convert the Auto Scaling configuration for service %s: %w", s.name, err)
 	}
@@ -90,7 +90,7 @@ func (s *BackendService) Template() (string, error) {
 		Sidecars:           sidecars,
 		Autoscaling:        autoscaling,
 		HealthCheck:        s.manifest.BackendServiceConfig.ImageConfig.HealthCheckOpts(),
-		LogConfig:          s.manifest.LogConfigOpts(),
+		LogConfig:          convertLogging(s.manifest.Logging),
 		DesiredCountLambda: desiredCountLambda.String(),
 	})
 	if err != nil {

internal/pkg/deploy/cloudformation/stack/backend_svc_test.go

@@ -53,11 +53,11 @@ func TestBackendService_Template(t *testing.T) {
 		Port: 8080,
 	}
 	testBackendSvcManifestWithBadSidecar := manifest.NewBackendService(baseProps)
-	testBackendSvcManifestWithBadSidecar.Sidecar = manifest.Sidecar{Sidecars: map[string]*manifest.SidecarConfig{
+	testBackendSvcManifestWithBadSidecar.Sidecars = map[string]*manifest.SidecarConfig{
 		"xray": {
 			Port: aws.String("80/80/80"),
 		},
-	}}
+	}
 	badRange := manifest.Range("badRange")
 	testBackendSvcManifestWithBadAutoScaling := manifest.NewBackendService(baseProps)
 	testBackendSvcManifestWithBadAutoScaling.Count.Autoscaling = manifest.Autoscaling{

internal/pkg/deploy/cloudformation/stack/lb_web_svc.go

@@ -104,11 +104,11 @@ func (s *LoadBalancedWebService) Template() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	sidecars, err := s.manifest.Sidecar.Options()
+	sidecars, err := convertSidecar(s.manifest.Sidecars)
 	if err != nil {
 		return "", fmt.Errorf("convert the sidecar configuration for service %s: %w", s.name, err)
 	}
-	autoscaling, err := s.manifest.Count.Autoscaling.Options()
+	autoscaling, err := convertAutoscaling(&s.manifest.Count.Autoscaling)
 	if err != nil {
 		return "", fmt.Errorf("convert the Auto Scaling configuration for service %s: %w", s.name, err)
 	}
@@ -117,9 +117,9 @@ func (s *LoadBalancedWebService) Template() (string, error) {
 		Secrets:             s.manifest.Secrets,
 		NestedStack:         outputs,
 		Sidecars:            sidecars,
-		LogConfig:           s.manifest.LogConfigOpts(),
+		LogConfig:           convertLogging(s.manifest.Logging),
 		Autoscaling:         autoscaling,
-		HTTPHealthCheck:     s.manifest.HealthCheck.HTTPHealthCheckOpts(),
+		HTTPHealthCheck:     convertHTTPHealthCheck(&s.manifest.HealthCheck),
 		AllowedSourceIps:    s.manifest.AllowedSourceIps,
 		RulePriorityLambda:  rulePriorityLambda.String(),
 		DesiredCountLambda:  desiredCountLambda.String(),

internal/pkg/deploy/cloudformation/stack/lb_web_svc_test.go

@@ -308,11 +308,11 @@ func TestLoadBalancedWebService_Parameters(t *testing.T) {
 		},
 	}
 	testLBWebServiceManifestWithSidecar.TargetContainer = aws.String("xray")
-	testLBWebServiceManifestWithSidecar.Sidecar = manifest.Sidecar{Sidecars: map[string]*manifest.SidecarConfig{
+	testLBWebServiceManifestWithSidecar.Sidecars = map[string]*manifest.SidecarConfig{
 		"xray": {
 			Port: aws.String("5000"),
 		},
-	}}
+	}
 	testLBWebServiceManifestWithStickiness := manifest.NewLoadBalancedWebService(baseProps)
 	testLBWebServiceManifestWithStickinessRange := manifest.Range("2-100")
 	testLBWebServiceManifestWithStickiness.Count = manifest.Count{

internal/pkg/deploy/cloudformation/stack/scheduled_job.go

@@ -122,7 +122,7 @@ func (j *ScheduledJob) Template() (string, error) {
 		return "", err
 	}
 
-	sidecars, err := j.manifest.Sidecar.Options()
+	sidecars, err := convertSidecar(j.manifest.Sidecars)
 	if err != nil {
 		return "", fmt.Errorf("convert the sidecar configuration for job %s: %w", j.name, err)
 	}
@@ -144,7 +144,7 @@ func (j *ScheduledJob) Template() (string, error) {
 		Sidecars:           sidecars,
 		ScheduleExpression: schedule,
 		StateMachine:       stateMachine,
-		LogConfig:          j.manifest.LogConfigOpts(),
+		LogConfig:          convertLogging(j.manifest.Logging),
 	})
 	if err != nil {
 		return "", fmt.Errorf("parse scheduled job template: %w", err)

internal/pkg/deploy/cloudformation/stack/transformers.go

@@ -0,0 +1,126 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package stack
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/copilot-cli/internal/pkg/manifest"
+	"github.com/aws/copilot-cli/internal/pkg/template"
+)
+
+const (
+	defaultSidecarPort = "80"
+)
+
+// convertSidecar converts the manifest sidecar configuration into a format parsable by the templates pkg.
+func convertSidecar(s map[string]*manifest.SidecarConfig) ([]*template.SidecarOpts, error) {
+	if s == nil {
+		return nil, nil
+	}
+	var sidecars []*template.SidecarOpts
+	for name, config := range s {
+		port, protocol, err := parsePortMapping(config.Port)
+		if err != nil {
+			return nil, err
+		}
+		sidecars = append(sidecars, &template.SidecarOpts{
+			Name:       aws.String(name),
+			Image:      config.Image,
+			Port:       port,
+			Protocol:   protocol,
+			CredsParam: config.CredsParam,
+			Secrets:    config.Secrets,
+			Variables:  config.Variables,
+		})
+	}
+	return sidecars, nil
+}
+
+// Valid sidecar portMapping example: 2000/udp, or 2000 (default to be tcp).
+func parsePortMapping(s *string) (port *string, protocol *string, err error) {
+	if s == nil {
+		// default port for sidecar container to be 80.
+		return aws.String(defaultSidecarPort), nil, nil
+	}
+	portProtocol := strings.Split(*s, "/")
+	switch len(portProtocol) {
+	case 1:
+		return aws.String(portProtocol[0]), nil, nil
+	case 2:
+		return aws.String(portProtocol[0]), aws.String(portProtocol[1]), nil
+	default:
+		return nil, nil, fmt.Errorf("cannot parse port mapping from %s", *s)
+	}
+}
+
+// convertAutoscaling converts the service's Auto Scaling configuration into a format parsable
+// by the templates pkg.
+func convertAutoscaling(a *manifest.Autoscaling) (*template.AutoscalingOpts, error) {
+	if a.IsEmpty() {
+		return nil, nil
+	}
+	min, max, err := a.Range.Parse()
+	if err != nil {
+		return nil, err
+	}
+	autoscalingOpts := template.AutoscalingOpts{
+		MinCapacity: &min,
+		MaxCapacity: &max,
+	}
+	if a.CPU != nil {
+		autoscalingOpts.CPU = aws.Float64(float64(*a.CPU))
+	}
+	if a.Memory != nil {
+		autoscalingOpts.Memory = aws.Float64(float64(*a.Memory))
+	}
+	if a.Requests != nil {
+		autoscalingOpts.Requests = aws.Float64(float64(*a.Requests))
+	}
+	if a.ResponseTime != nil {
+		responseTime := float64(*a.ResponseTime) / float64(time.Second)
+		autoscalingOpts.ResponseTime = aws.Float64(responseTime)
+	}
+	return &autoscalingOpts, nil
+}
+
+// convertHTTPHealthCheck converts the ALB health check configuration into a format parsable by the templates pkg.
+func convertHTTPHealthCheck(hc *manifest.HealthCheckArgsOrString) template.HTTPHealthCheckOpts {
+	opts := template.HTTPHealthCheckOpts{
+		HealthCheckPath:    manifest.DefaultHealthCheckPath,
+		HealthyThreshold:   hc.HealthCheckArgs.HealthyThreshold,
+		UnhealthyThreshold: hc.HealthCheckArgs.UnhealthyThreshold,
+	}
+	if hc.HealthCheckArgs.Path != nil {
+		opts.HealthCheckPath = *hc.HealthCheckArgs.Path
+	} else if hc.HealthCheckPath != nil {
+		opts.HealthCheckPath = *hc.HealthCheckPath
+	}
+	if hc.HealthCheckArgs.Interval != nil {
+		opts.Interval = aws.Int64(int64(hc.HealthCheckArgs.Interval.Seconds()))
+	}
+	if hc.HealthCheckArgs.Timeout != nil {
+		opts.Timeout = aws.Int64(int64(hc.HealthCheckArgs.Timeout.Seconds()))
+	}
+	return opts
+}
+
+func convertLogging(lc *manifest.Logging) *template.LogConfigOpts {
+	if lc == nil {
+		return nil
+	}
+	return logConfigOpts(lc)
+}
+func logConfigOpts(lc *manifest.Logging) *template.LogConfigOpts {
+	return &template.LogConfigOpts{
+		Image:          lc.LogImage(),
+		ConfigFile:     lc.ConfigFile,
+		EnableMetadata: lc.GetEnableMetadata(),
+		Destination:    lc.Destination,
+		SecretOptions:  lc.SecretOptions,
+	}
+}