#55 read input from stdin

scrap reading code from stdin

Author: andystanton

README.md

@@ -85,6 +85,20 @@ By default, ```dexec``` assumes the sources are in the directory from which it i
 $ dexec -C /path/to/sources foo.cpp bar.cpp
 ```
 
+### Read from STDIN
+
+```dexec``` will forward your terminal's STDIN to the executing code. You can redirect from a file or use pipe:
+
+```sh
+$ dexec foo.cpp <input.txt
+```
+
+```sh
+$ curl http://input | foo.cpp
+```
+
+If using keyboard entry, ctrl-d (EOF) will terminate reading from STDIN.
+
 ### Include files and folders
 
 Individual files can be mounted without being passed to the compiler, for example header files in C & C++, or input files for program execution. These can be included in the following way.
@@ -131,35 +145,6 @@ $ dexec foo.c -e cpp
 
 This will cause ```dexec``` to attempt to lookup the image for the supplied extension in its map.
 
-### Reading from STDIN
-
-If no source files are specified, ```dexec``` will read from STDIN. Both manual entry and piping are supported. In both cases ```dexec``` writes the contents of STDIN to a temporary file, executes it and then removes it.
-
-```dexec``` requires either the [extension](#override-image-by-file-extension) or [image](#override-image-by-nametag) to be supplied.
-
-#### Manual entry
-
-Text may be entered until EOF is received (Ctrl-D).
-
-```sh
-$ dexec --extension js
-Enter your code. Ctrl-D to exit
-console.log('hello world')
-<Ctrl-D>
-
-hello world
-```
-
-#### Pipe
-
-```sh
-$ echo "console.log('hello world')" | dexec --extension js
-```
-
-```sh
-$ curl "http://some-url.com/foo.cpp" | dexec --image dexec/lang-cpp
-```
-
 ### Force dexec to pull latest version of image
 
 Primarily for debugging purposes, the --update command triggers a ```docker pull``` of the target image before executing the code.

cli/cli.go

@@ -162,16 +162,13 @@ func DisplayHelp(filename string) {
 	fmt.Println("Usage:")
 	fmt.Printf("\t%s [options] <source files...>\n", filename)
 	fmt.Println()
-	fmt.Println("\tIf no source files are specified, input will be read from stdin. This requires")
-	fmt.Println("\tthe image or extension to be set using --extension or --image.")
-	fmt.Println()
 	fmt.Println("Options:")
 	fmt.Printf("\t%-36s%s\n", "-C <dir>", "Specify source directory")
 	fmt.Printf("\t%-36s%s\n", "--arg, -a <argument>", "Pass <argument> to the executing code")
 	fmt.Printf("\t%-36s%s\n", "--build-arg, -b <build argument>", "Pass <build argument> to compiler")
 	fmt.Printf("\t%-36s%s\n", "--include, -i <file|path>", "Mount local <file|path> in dexec container")
-	fmt.Printf("\t%-36s%s\n", "--extension, -e <extension>", "Override the extension used to select image")
-	fmt.Printf("\t%-36s%s\n", "--image, -m <docker image>", "Override the image used with <docker image>")
+	fmt.Printf("\t%-36s%s\n", "--extension, -e <extension>", "Override the image used by <extension>")
+	fmt.Printf("\t%-36s%s\n", "--image, -m <name>", "Override the image used by <name>")
 	fmt.Printf("\t%-36s%s\n", "--update, -u", "Force update of image")
 	fmt.Printf("\t%-36s%s\n", "--clean", "Remove all local dexec images")
 	fmt.Printf("\t%-36s%s\n", "--help, -h", "Show help")

main.go

@@ -5,11 +5,8 @@ import (
 	"log"
 	"os"
 	"regexp"
-	"strings"
 	"time"
 
-	uuid "github.com/satori/go.uuid"
-
 	"github.com/docker-exec/dexec/cli"
 	"github.com/docker-exec/dexec/dexec"
 	"github.com/docker-exec/dexec/util"
@@ -19,14 +16,11 @@ import (
 // RunDexecContainer runs an anonymous Docker container with a Docker Exec
 // image, mounting the specified sources and includes and passing the
 // list of sources and arguments to the entrypoint.
-func RunDexecContainer(cliParser cli.CLI) {
+func RunDexecContainer(cliParser cli.CLI) int {
 	options := cliParser.Options
 
-	hasSources := len(options[cli.Source]) > 0
 	shouldClean := len(options[cli.CleanFlag]) > 0
 	updateImage := len(options[cli.UpdateFlag]) > 0
-	useExtension := len(options[cli.Extension]) == 1
-	useImage := len(options[cli.Image]) == 1
 
 	client, err := docker.NewClientFromEnv()
 
@@ -51,97 +45,92 @@ func RunDexecContainer(cliParser cli.CLI) {
 		}
 	}
 
-	if hasSources || useExtension || useImage {
-		dexecImage, err := dexec.ImageFromOptions(options)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		dockerImage := fmt.Sprintf("%s:%s", dexecImage.Image, dexecImage.Version)
-
-		if !hasSources {
-			lines := util.ReadStdin("Enter your code. Ctrl-D to exit", "<Ctrl-D>")
-			tmpFile := fmt.Sprintf("%s.%s", uuid.NewV4(), dexecImage.Extension)
-
-			util.WriteFile(tmpFile, []byte(strings.Join(lines, "\n")))
-			defer func() {
-				util.DeleteFile(tmpFile)
-			}()
-
-			options[cli.Source] = []string{tmpFile}
-		}
+	dexecImage, err := dexec.ImageFromOptions(options)
+	if err != nil {
+		log.Fatal(err)
+	}
 
-		if err := dexec.FetchImage(
-			dexecImage.Image,
-			dexecImage.Version,
-			updateImage,
-			client); err != nil {
-			log.Fatal(err)
-		}
+	dockerImage := fmt.Sprintf("%s:%s", dexecImage.Image, dexecImage.Version)
 
-		var sourceBasenames []string
-		for _, source := range options[cli.Source] {
-			basename, _ := dexec.ExtractBasenameAndPermission(source)
-			sourceBasenames = append(sourceBasenames, []string{basename}...)
-		}
+	if err := dexec.FetchImage(
+		dexecImage.Image,
+		dexecImage.Version,
+		updateImage,
+		client); err != nil {
+		log.Fatal(err)
+	}
 
-		entrypointArgs := util.JoinStringSlices(
-			sourceBasenames,
-			util.AddPrefix(options[cli.BuildArg], "-b"),
-			util.AddPrefix(options[cli.Arg], "-a"),
-		)
-
-		container, err := client.CreateContainer(docker.CreateContainerOptions{
-			Config: &docker.Config{
-				Image: dockerImage,
-				Cmd:   entrypointArgs,
-			},
-		})
+	var sourceBasenames []string
+	for _, source := range options[cli.Source] {
+		basename, _ := dexec.ExtractBasenameAndPermission(source)
+		sourceBasenames = append(sourceBasenames, []string{basename}...)
+	}
 
-		if err != nil {
-			log.Fatal(err)
-		}
+	entrypointArgs := util.JoinStringSlices(
+		sourceBasenames,
+		util.AddPrefix(options[cli.BuildArg], "-b"),
+		util.AddPrefix(options[cli.Arg], "-a"),
+	)
+
+	container, err := client.CreateContainer(docker.CreateContainerOptions{
+		Config: &docker.Config{
+			Image:     dockerImage,
+			Cmd:       entrypointArgs,
+			StdinOnce: true,
+			OpenStdin: true,
+		},
+	})
 
-		defer func() {
-			if err = client.RemoveContainer(docker.RemoveContainerOptions{
-				ID: container.ID,
-			}); err != nil {
-				log.Fatal(err)
-			}
-		}()
+	if err != nil {
+		log.Fatal(err)
+	}
 
-		if err = client.StartContainer(container.ID, &docker.HostConfig{
-			Binds: dexec.BuildVolumeArgs(
-				util.RetrievePath(options[cli.TargetDir]),
-				append(options[cli.Source], options[cli.Include]...)),
+	defer func() {
+		if err = client.RemoveContainer(docker.RemoveContainerOptions{
+			ID: container.ID,
 		}); err != nil {
 			log.Fatal(err)
 		}
+	}()
 
+	if err = client.StartContainer(container.ID, &docker.HostConfig{
+		Binds: dexec.BuildVolumeArgs(
+			util.RetrievePath(options[cli.TargetDir]),
+			append(options[cli.Source], options[cli.Include]...)),
+	}); err != nil {
+		log.Fatal(err)
+	}
+
+	go func() {
 		if err = client.AttachToContainer(docker.AttachToContainerOptions{
 			Container:    container.ID,
 			OutputStream: os.Stdout,
 			ErrorStream:  os.Stderr,
+			InputStream:  os.Stdin,
 			Stream:       true,
 			Stdout:       true,
 			Stderr:       true,
-			Logs:         true,
+			Stdin:        true,
 		}); err != nil {
 			log.Fatal(err)
 		}
+	}()
+
+	code, err := client.WaitContainer(container.ID)
+	if err != nil {
+		log.Fatal(err)
 	}
+	return code
 }
 
 func validate(cliParser cli.CLI) bool {
 	options := cliParser.Options
 
 	hasVersionFlag := len(options[cli.VersionFlag]) == 1
-	hasExtension := len(options[cli.Extension]) == 1
-	hasImage := len(options[cli.Image]) == 1
 	hasSources := len(options[cli.Source]) > 0
 	shouldClean := len(options[cli.CleanFlag]) > 0
 
-	if hasSources || hasImage || hasExtension || shouldClean {
+	if hasSources || shouldClean {
 		return true
 	}
 
@@ -180,7 +169,7 @@ func main() {
 		if err := validateDocker(); err != nil {
 			log.Fatal(err)
 		} else {
-			RunDexecContainer(cliParser)
+			os.Exit(RunDexecContainer(cliParser))
 		}
 	}
 }