Merge pull request #136 from dexhorthy/fix-helm-chart-deps

Fix helm location, fetch deps

Author: dexhorthy

examples/helm/github.yml

@@ -0,0 +1,22 @@
+assets:
+  v1:
+    - github:
+       repo: kubernetes/charts
+       path: stable/jasperreports
+       ref: fd35ab34bfd26878fb5970fbc7c3e75760df10ec
+       source: public
+       dest: jasperreports
+    - helm:
+        dest: charts
+        github:
+          repo: kubernetes/charts
+          path: stable/jasperreports
+          ref: fd35ab34bfd26878fb5970fbc7c3e75760df10ec
+          source: public
+
+config:
+  v1: []
+
+lifecycle:
+  v1:
+    - render: {}

pkg/e2e/vendor_client.go

@@ -61,7 +61,8 @@ mutation($channelId: ID!, $semver: String!, $spec: String!, $releaseNotes: Strin
 		semver: $semver
 		spec: $spec
 		releaseNotes: $releaseNotes
-)
+) {
+  id }
 }`,
 		Variables: map[string]string{
 			"spec":         spec,

pkg/lifecycle/render/helm/fetch.go

@@ -66,7 +66,7 @@ func (f *ClientFetcher) FetchChart(
 			return "", errors.Wrap(err, "fetch github asset")
 		}
 
-		return checkoutDir, nil
+		return path.Join(checkoutDir, asset.GitHub.Path), nil
 	}
 
 	debug.Log("event", "chart.fetch.fail", "reason", "unsupported")

pkg/lifecycle/render/helm/template.go

@@ -73,25 +73,23 @@ func (f *ForkTemplater) Template(
 		cmd.Args = append(cmd.Args, asset.HelmOpts...)
 	}
 
-	configCtx, err := f.BuilderBuilder.NewConfigContext(configGroups, templateContext)
+	args, err := f.appendHelmValues(configGroups, templateContext, asset)
 	if err != nil {
-		return errors.Wrap(err, "create config context")
+		return errors.Wrap(err, "build helm values")
 	}
-	builder := f.BuilderBuilder.NewBuilder(
-		f.BuilderBuilder.NewStaticContext(),
-		configCtx,
-	)
+	cmd.Args = append(cmd.Args, args...)
 
-	if asset.Values != nil {
-		for key, value := range asset.Values {
-			if err := appendHelmValue(value, builder, cmd, key); err != nil {
-				return errors.Wrapf(err, "append helm value %s", key)
-			}
-		}
+	err = f.helmInitClient(chartRoot)
+	if err != nil {
+		return errors.Wrap(err, "init helm client")
 	}
 
-	stdout, stderr, err := f.fork(cmd)
+	err = f.helmDependencyUpdate(chartRoot)
+	if err != nil {
+		return errors.Wrap(err, "update helm dependencies")
+	}
 
+	stdout, stderr, err := f.fork(cmd)
 	if err != nil {
 		debug.Log("event", "cmd.err")
 		if exitError, ok := err.(*exec.ExitError); ok && !exitError.Success() {
@@ -104,21 +102,52 @@ func (f *ForkTemplater) Template(
 	return nil
 }
 
-func appendHelmValue(value interface{}, builder templates.Builder, cmd *exec.Cmd, key string) error {
+func (f *ForkTemplater) appendHelmValues(
+	configGroups []libyaml.ConfigGroup,
+	templateContext map[string]interface{},
+	asset api.HelmAsset,
+) ([]string, error) {
+	var cmdArgs []string
+	configCtx, err := f.BuilderBuilder.NewConfigContext(configGroups, templateContext)
+	if err != nil {
+		return nil, errors.Wrap(err, "create config context")
+	}
+	builder := f.BuilderBuilder.NewBuilder(
+		f.BuilderBuilder.NewStaticContext(),
+		configCtx,
+	)
+	if asset.Values != nil {
+		for key, value := range asset.Values {
+			args, err := appendHelmValue(value, builder, cmdArgs, key)
+			if err != nil {
+				return nil, errors.Wrapf(err, "append helm value %s", key)
+			}
+			cmdArgs = append(cmdArgs, args...)
+		}
+	}
+	return cmdArgs, nil
+}
+
+func appendHelmValue(
+	value interface{},
+	builder templates.Builder,
+	args []string,
+	key string,
+) ([]string, error) {
 	stringValue, ok := value.(string)
 	if !ok {
-		cmd.Args = append(cmd.Args, "--set")
-		cmd.Args = append(cmd.Args, fmt.Sprintf("%s=%s", key, value))
-		return nil
+		args = append(args, "--set")
+		args = append(args, fmt.Sprintf("%s=%s", key, value))
+		return args, nil
 	}
 
 	renderedValue, err := builder.String(stringValue)
 	if err != nil {
-		return errors.Wrapf(err, "render value for %s", key)
+		return nil, errors.Wrapf(err, "render value for %s", key)
 	}
-	cmd.Args = append(cmd.Args, "--set")
-	cmd.Args = append(cmd.Args, fmt.Sprintf("%s=%s", key, renderedValue))
-	return nil
+	args = append(args, "--set")
+	args = append(args, fmt.Sprintf("%s=%s", key, renderedValue))
+	return args, nil
 }
 
 func (f *ForkTemplater) fork(cmd *exec.Cmd) ([]byte, []byte, error) {
@@ -164,6 +193,52 @@ func (f *ForkTemplater) fork(cmd *exec.Cmd) ([]byte, []byte, error) {
 
 	return stdout, stderr, err
 }
+func (f *ForkTemplater) helmDependencyUpdate(chartRoot string) error {
+	debug := level.Debug(log.With(f.Logger, "step.type", "render", "render.phase", "execute", "asset.type", "helm", "render.step", "helm.dependencyUpdate"))
+	cmd := f.Helm()
+	cmd.Args = append(cmd.Args,
+		"dependency",
+		"update",
+		chartRoot,
+	)
+
+	debug.Log("event", "helm.update", "args", cmd.Args)
+
+	stdout, stderr, err := f.fork(cmd)
+
+	if err != nil {
+		debug.Log("event", "cmd.err")
+		if exitError, ok := err.(*exec.ExitError); ok && !exitError.Success() {
+			return errors.Errorf(`execute helm dependency update: %s: stdout: "%s"; stderr: "%s";`, exitError.Error(), stdout, stderr)
+		}
+		return errors.Wrap(err, "execute helm dependency update")
+	}
+
+	return nil
+}
+
+func (f *ForkTemplater) helmInitClient(chartRoot string) error {
+	debug := level.Debug(log.With(f.Logger, "step.type", "render", "render.phase", "execute", "asset.type", "helm"))
+	cmd := f.Helm()
+	cmd.Args = append(cmd.Args,
+		"init",
+		"--client-only",
+	)
+
+	debug.Log("event", "helm.initClient", "args", cmd.Args)
+
+	stdout, stderr, err := f.fork(cmd)
+
+	if err != nil {
+		debug.Log("event", "cmd.err")
+		if exitError, ok := err.(*exec.ExitError); ok && !exitError.Success() {
+			return errors.Errorf(`execute helm dependency update: %s: stdout: "%s"; stderr: "%s";`, exitError.Error(), stdout, stderr)
+		}
+		return errors.Wrap(err, "execute helm dependency update")
+	}
+
+	return nil
+}
 
 // NewTemplater returns a configured Templater. For now we just always fork
 func NewTemplater(

pkg/lifecycle/render/helm/template_test.go

@@ -193,6 +193,19 @@ func TestMockHelm(t *testing.T) {
 		return
 	}
 
+	receivedArgs := os.Args[2:]
+	expectInit := []string{"init", "--client-only"}
+	expectUpdate := []string{"dependency", "update", "/tmp/chartroot"}
+	if reflect.DeepEqual(receivedArgs, expectInit) {
+		// we good, these are exepcted calls, and we just need to test one type of forking
+		os.Exit(0)
+	}
+
+	if reflect.DeepEqual(receivedArgs, expectUpdate) {
+		// we good, these are exepcted calls
+		os.Exit(0)
+	}
+
 	if os.Getenv("CRASHING_HELM_ERROR") != "" {
 		fmt.Fprintf(os.Stdout, os.Getenv("CRASHING_HELM_ERROR"))
 		os.Exit(1)
@@ -201,7 +214,6 @@ func TestMockHelm(t *testing.T) {
 	if os.Getenv("EXPECT_HELM_ARGV") != "" {
 		// this is janky, but works for our purposes, use pipe | for separator, since its unlikely to be in argv
 		expectedArgs := strings.Split(os.Getenv("EXPECT_HELM_ARGV"), "|")
-		receivedArgs := os.Args[2:]
 
 		fmt.Fprintf(os.Stderr, "expected args %v, got args %v", expectedArgs, receivedArgs)
 		if !reflect.DeepEqual(receivedArgs, expectedArgs) {