Merge pull request #437 from silvin-lubecki/remove-commands

Remove Helm and Fork commands

Author: simonferquel

README.md

@@ -160,26 +160,6 @@ cp docker-app-linux /usr/local/bin/docker-app
 
 **Note:** To use Application Packages as images (i.e.: `save`, `push`, or `deploy` when package is not present locally) on Windows, one must be in Linux container mode.
 
-## Integrating with Helm
-
-`docker-app` comes with a few other helpful commands as well, in particular the ability to create Helm Charts from your Docker Applications. This can be useful if you're adopting Kubernetes, and standardising on Helm to manage the lifecycle of your application components, but want to maintain the simplicity of Compose when writing you applications. This also makes it easy to run the same applications locally just using Docker, if you don't want to be running a full Kubernetes cluster.
-
-```
-$ docker-app helm
-```
-
-This will create a folder, `<my-application-name>.chart`, in the current directory. The folder contains the required `Chart.yaml` file and templates describing the `stack` Kubernetes object based on the Compose file in your application.
-
-_Note that this requires the Compose Kubernetes controller available in Docker for Windows and Docker for Mac, and in Docker Enterprise Edition._
-
-### Helm chart for Docker EE 2.0
-
-In order to create a helm chart that is compatible with version 2.0 of Docker Enterprise Edition, you will need to use the `--stack-version` flag to create a compatible version of the helm chart using `v1beta1` like so:
-
-```bash
-$ docker-app helm --stack-version=v1beta1
-```
-
 ## Single file or directory representation
 
 If you prefer having the three core documents in separate YAML files, omit the `-s` / `--single-file` option to
@@ -213,22 +193,6 @@ All `docker-app` commands accept an image name as input, which means you can run
 $ docker-app inspect myhubuser/hello
 ```
 
-## Forking an existing image
-
-Found an app on a remote registry you'd like to modify to better suit your needs? Use the `fork` subcommand:
-
-```bash
-$ docker-app fork remote/hello.dockerapp:1.0.0 mine/hello2 -m "Bob Dylan:bob@aol.com"
-```
-
-This command will create a local, editable copy of the app on your system. By default, the copy is created inside the current directory; you may use the `--path` flag to configure a different destination.
-
-For example, the following will create the `/opt/myapps/hello2.dockerapp` folder containing the forked app's files:
-
-```bash
-$ docker-app fork remote/hello.dockerapp:1.0.0 mine/hello2 --path /opt/myapps
-```
-
 ## Next steps
 
 We have lots of ideas for making Compose-based applications easier to share and reuse, and making applications a first-class part of the Docker toolchain. Please let us know what you think about this initial release and about any of the ideas below:
@@ -264,8 +228,6 @@ Options:
 Commands:
   completion  Generates completion scripts for the specified shell (bash or zsh)
   deploy      Deploy or update an application
-  fork        Create a fork of an existing application to be modified
-  helm        Generate a Helm chart
   init        Start building a Docker application
   inspect     Shows metadata, settings and a summary of the compose file for a given application
   merge       Merge a multi-file application into a single file

cmd/docker-app/fork.go

@@ -44,8 +44,6 @@ func newRootCmd(dockerCli *command.DockerCli) *cobra.Command {
 func addCommands(cmd *cobra.Command, dockerCli command.Cli) {
 	cmd.AddCommand(
 		deployCmd(dockerCli),
-		forkCmd(),
-		helmCmd(),
 		initCmd(),
 		inspectCmd(dockerCli),
 		mergeCmd(dockerCli),

cmd/docker-app/helm.go

@@ -78,7 +78,7 @@ func testRenderApp(appPath string, env ...string) func(*testing.T) {
 }
 
 func TestRenderFormatters(t *testing.T) {
-	appPath := filepath.Join("testdata", "fork", "simple.dockerapp")
+	appPath := filepath.Join("testdata", "simple", "simple.dockerapp")
 	result := icmd.RunCommand(dockerApp, "render", "--formatter", "json", appPath).Assert(t, icmd.Success)
 	assert.Assert(t, golden.String(result.Stdout(), "expected-json-render.golden"))
 
@@ -157,7 +157,7 @@ maintainers:
 func TestDetectApp(t *testing.T) {
 	// cwd = e2e
 	dir := fs.NewDir(t, "detect-app-binary",
-		fs.WithDir("helm.dockerapp", fs.FromDir("testdata/helm.dockerapp")),
+		fs.WithDir("attachments.dockerapp", fs.FromDir("testdata/attachments.dockerapp")),
 		fs.WithDir("render",
 			fs.WithDir("app1.dockerapp", fs.FromDir("testdata/render/envvariables/my.dockerapp")),
 			fs.WithDir("app2.dockerapp", fs.FromDir("testdata/render/envvariables/my.dockerapp")),
@@ -170,11 +170,11 @@ func TestDetectApp(t *testing.T) {
 	}).Assert(t, icmd.Success)
 	icmd.RunCmd(icmd.Cmd{
 		Command: []string{dockerApp, "inspect"},
-		Dir:     dir.Join("helm.dockerapp"),
+		Dir:     dir.Join("attachments.dockerapp"),
 	}).Assert(t, icmd.Success)
 	icmd.RunCmd(icmd.Cmd{
 		Command: []string{dockerApp, "inspect", "."},
-		Dir:     dir.Join("helm.dockerapp"),
+		Dir:     dir.Join("attachments.dockerapp"),
 	}).Assert(t, icmd.Success)
 	result := icmd.RunCmd(icmd.Cmd{
 		Command: []string{dockerApp, "inspect"},
@@ -191,20 +191,14 @@ func TestPack(t *testing.T) {
 	tempDir, err := ioutil.TempDir("", "dockerapp")
 	assert.NilError(t, err)
 	defer os.RemoveAll(tempDir)
-	icmd.RunCommand(dockerApp, "pack", "testdata/helm", "-o", filepath.Join(tempDir, "test.dockerapp")).Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "pack", "testdata/attachments", "-o", filepath.Join(tempDir, "test.dockerapp")).Assert(t, icmd.Success)
 	// check that our commands run on the packed version
 	icmd.RunCommand(dockerApp, "inspect", filepath.Join(tempDir, "test")).Assert(t, icmd.Expected{
 		Out: "myapp",
 	})
 	icmd.RunCommand(dockerApp, "render", filepath.Join(tempDir, "test")).Assert(t, icmd.Expected{
 		Out: "nginx",
 	})
-	icmd.RunCmd(icmd.Cmd{
-		Command: []string{dockerApp, "helm", "test"},
-		Dir:     tempDir,
-	}).Assert(t, icmd.Success)
-	_, err = os.Stat(filepath.Join(tempDir, "test.chart", "Chart.yaml"))
-	assert.NilError(t, err)
 	assert.NilError(t, os.Mkdir(filepath.Join(tempDir, "output"), 0755))
 	icmd.RunCmd(icmd.Cmd{
 		Command: []string{dockerApp, "unpack", "test", "-o", "output"},
@@ -214,41 +208,6 @@ func TestPack(t *testing.T) {
 	assert.NilError(t, err)
 }
 
-func TestHelm(t *testing.T) {
-	t.Run("default", testHelm(""))
-	t.Run("v1beta1", testHelm("v1beta1"))
-	t.Run("v1beta2", testHelm("v1beta2"))
-}
-
-func testHelm(version string) func(*testing.T) {
-	return func(t *testing.T) {
-		dir := fs.NewDir(t, "testHelmBinary", fs.FromDir("testdata"))
-		defer dir.Remove()
-		cmd := []string{dockerApp, "helm", "helm", "-s", "myapp.nginx_version=2"}
-		if version != "" {
-			cmd = append(cmd, "--stack-version", version)
-		}
-		icmd.RunCmd(icmd.Cmd{
-			Command: cmd,
-			Dir:     dir.Path(),
-		}).Assert(t, icmd.Success)
-
-		chart := golden.Get(t, dir.Join("helm.chart/Chart.yaml"))
-		values := golden.Get(t, dir.Join("helm.chart/values.yaml"))
-		stack := golden.Get(t, dir.Join("helm.chart/templates/stack.yaml"))
-		assert.Check(t, golden.String(string(chart), "helm-expected.chart/Chart.yaml"))
-		assert.Check(t, golden.String(string(values), "helm-expected.chart/values.yaml"))
-		assert.Check(t, golden.String(string(stack), "helm-expected.chart/templates/stack"+version+".yaml"))
-	}
-}
-
-func TestHelmInvalidStackVersion(t *testing.T) {
-	icmd.RunCommand(dockerApp, "helm", "testdata/helm", "--stack-version", "foobar").Assert(t, icmd.Expected{
-		ExitCode: 1,
-		Err:      `Error: invalid stack version "foobar" (accepted values: v1beta1, v1beta2)`,
-	})
-}
-
 func TestSplitMerge(t *testing.T) {
 	icmd.RunCommand(dockerApp, "merge", "testdata/render/envvariables/my.dockerapp", "-o", "remerged.dockerapp").Assert(t, icmd.Success)
 	defer os.Remove("remerged.dockerapp")
@@ -275,47 +234,21 @@ func TestWithRegistry(t *testing.T) {
 	r := startRegistry(t)
 	defer r.Stop(t)
 	registry := r.GetAddress(t)
-	t.Run("image", testImage(registry))
-	t.Run("fork", testFork(registry))
-}
-
-func testImage(registry string) func(*testing.T) {
-	return func(t *testing.T) {
-		// push to a registry
-		icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", "-t", "latest", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my.dockerapp:0.1.0").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my.dockerapp").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my:0.1.0").Assert(t, icmd.Success)
-		// push a single-file app to a registry
-		dir := fs.NewDir(t, "save-prepare-build", fs.WithFile("my.dockerapp", singleFileApp))
-		defer dir.Remove()
-		icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", dir.Join("my.dockerapp")).Assert(t, icmd.Success)
-
-		// push with custom repo name
-		icmd.RunCommand(dockerApp, "push", "-t", "marshmallows", "--namespace", registry+"/rainbows", "--repo", "unicorns", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
-		icmd.RunCommand(dockerApp, "inspect", registry+"/rainbows/unicorns:marshmallows").Assert(t, icmd.Success)
-	}
-}
-
-func testFork(registry string) func(*testing.T) {
-	return func(t *testing.T) {
-		icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/acmecorp", "testdata/fork/simple").Assert(t, icmd.Success)
-
-		tempDir := fs.NewDir(t, "dockerapptest")
-		defer tempDir.Remove()
-
-		icmd.RunCommand(dockerApp, "fork", registry+"/acmecorp/simple.dockerapp:1.1.0-beta1", "acmecorp/scarlet.devil",
-			"-p", tempDir.Path(), "-m", "Remilia Scarlet:remilia@acmecorp.cool").Assert(t, icmd.Success)
-		metadata := golden.Get(t, tempDir.Join("scarlet.devil.dockerapp", "metadata.yml"))
-		assert.Assert(t, golden.Bytes(metadata, "expected-fork-metadata.golden"))
+	// push to a registry
+	icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", "-t", "latest", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my.dockerapp:0.1.0").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my.dockerapp").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "inspect", registry+"/myuser/my:0.1.0").Assert(t, icmd.Success)
+	// push a single-file app to a registry
+	dir := fs.NewDir(t, "save-prepare-build", fs.WithFile("my.dockerapp", singleFileApp))
+	defer dir.Remove()
+	icmd.RunCommand(dockerApp, "push", "--namespace", registry+"/myuser", dir.Join("my.dockerapp")).Assert(t, icmd.Success)
 
-		icmd.RunCommand(dockerApp, "fork", registry+"/acmecorp/simple.dockerapp:1.1.0-beta1",
-			"-p", tempDir.Path(), "-m", "Remilia Scarlet:remilia@acmecorp.cool").Assert(t, icmd.Success)
-		metadata2 := golden.Get(t, tempDir.Join("simple.dockerapp", "metadata.yml"))
-		assert.Assert(t, golden.Bytes(metadata2, "expected-fork-metadata-no-rename.golden"))
-	}
+	// push with custom repo name
+	icmd.RunCommand(dockerApp, "push", "-t", "marshmallows", "--namespace", registry+"/rainbows", "--repo", "unicorns", "testdata/render/envvariables/my.dockerapp").Assert(t, icmd.Success)
+	icmd.RunCommand(dockerApp, "inspect", registry+"/rainbows/unicorns:marshmallows").Assert(t, icmd.Success)
 }
 
 func TestAttachmentsWithRegistry(t *testing.T) {
@@ -339,16 +272,4 @@ func TestAttachmentsWithRegistry(t *testing.T) {
 	assert.Assert(t, strings.Contains(resultOutput, "config.cfg"))
 	assert.Assert(t, strings.Contains(resultOutput, "nesteddir/config2.cfg"))
 	assert.Assert(t, strings.Contains(resultOutput, "nesteddir/nested2/nested3/config3.cfg"))
-
-	// Test forking with external files
-	tempDir := fs.NewDir(t, "dockerapptest")
-	defer tempDir.Remove()
-
-	icmd.RunCommand(dockerApp, "fork", registry+"/acmecorp/attachments.dockerapp:0.1.0",
-		"-p", tempDir.Path()).Assert(t, icmd.Success)
-	externalFile := golden.Get(t, tempDir.Join("attachments.dockerapp", "config.cfg"))
-	assert.Assert(t, golden.Bytes(externalFile, filepath.Join("attachments.dockerapp", "config.cfg")))
-
-	nestedAttachment := golden.Get(t, tempDir.Join("attachments.dockerapp", "nesteddir", "config2.cfg"))
-	assert.Assert(t, golden.Bytes(nestedAttachment, filepath.Join("attachments.dockerapp", "nesteddir", "config2.cfg")))
 }