Comments and README for multibuild

Author: CAFxX

README.md

@@ -1,20 +1,24 @@
 # pluggo
 Golang compile-time, in-process plugin framework
 
+[![GoDoc](https://godoc.org/github.com/CAFxX/pluggo?status.svg)](https://godoc.org/github.com/CAFxX/pluggo)
+
 ## Purpose
 Pluggo allows you to define interface-based extension points in your code, so
 that users of your code can plug in their modifications at compile time while
 keeping the application code and plugin code in completely separated packages
-and repositories. Compared to RPC/IPC approaches, plugins using this framework
-run in the same process as the application, with no IPC/RPC overhead.
+and repositories.
+
+Compared to RPC/IPC approaches, plugins using this framework run in the same
+process as the application with no IPC/RPC overhead.
 
 ## How it works
 Similarly as how `database/sql` drivers registers themselves: there's a
 "extension point registry" (just a `map[string]func() interface{}`) where
 plugins `Register` their factories for the appropriate extension points.
 Application code at each extension point requests to the registry instances of
 the plugin using `Get`. Application and plugins are then compiled and linked
-together in the same executable with the `multibuild` tool.
+together in the same executable with the `[multibuild](cmd/multibuild)` tool.
 
 ## Examples
 
@@ -73,8 +77,8 @@ packages (the plugins).
 $ multibuild appMainPkg pluginPkg1 pluginPkg2 ...
 ```
 
-You can have a look at the [sample](sample/README.md) directory for a
-ready-to-run example.
+You can have a look at the [sample](sample) directory for a ready-to-run
+example.
 
 ### Factory pattern
 

cmd/multibuild/README.md

@@ -0,0 +1,13 @@
+# multibuild
+A small tool to build and link together multiple go packages
+
+## Purpose
+This tool was designed to work with [pluggo](../..), to perform linking of
+plugins with the application/library they're intended for.
+
+It can also be used in other cases, where you're importing a package only for
+its side-effects, e.g.:
+
+- To link additional `database/sql` drivers
+- To link `pprof` at compile-time
+- ...

cmd/multibuild/multibuild.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"go/build"
 	"io/ioutil"
-	"log"
 	"os"
 	"os/exec"
 
@@ -22,42 +21,56 @@ func usage() {
 	fmt.Println("The resulting build will have the package name of <mainPkg>")
 }
 
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-
-	if len(flag.Args()) == 0 {
-		fmt.Println("missing arguments")
-		usage()
-		os.Exit(-1)
-	}
-
-	pkgs := gotool.ImportPaths(flag.Args())
+func multibuild(packages []string) (error, int) {
+	// parse the names of the paths/packages provided on the command-line
+	pkgs := gotool.ImportPaths(packages)
 
+	// parse the main package: we need the package name and the path
 	mainpkg, err := build.Import(pkgs[0], ".", 0)
 	if err != nil {
-		log.Printf("unable to import main package %s: %s", pkgs[0], err)
-		os.Exit(-2)
+		return fmt.Errorf("unable to import main package %s: %s", pkgs[0], err), -2
 	}
 
+	// create the linker file in the main package directory, so that it will be
+	// compiled and linked with the main package when we `go build` is invoked
+	// the linker file is a go file in the same package of the main package that
+	// imports all additional packages (normally for their side-effects)
 	tmpFile, err := ioutil.TempFile(mainpkg.Dir, "pluggo")
 	if err != nil {
-		log.Printf("unable to create temporary file: %s", err)
-		os.Exit(-3)
+		return fmt.Errorf("unable to create temporary file: %s", err), -3
 	}
 
 	fmt.Fprintf(tmpFile, "package %s\n", mainpkg.Name)
-	for _, pkgname := range os.Args[2:] {
+	for _, pkgname := range pkgs[1:] {
 		fmt.Fprintf(tmpFile, "import _ \"%s\"\n", pkgname)
 	}
 
 	tmpFile.Close()
 	os.Rename(tmpFile.Name(), tmpFile.Name()+".go")
 	defer os.Remove(tmpFile.Name() + ".go")
 
-	output, err := exec.Command("go", "build", flag.Args()[0]).CombinedOutput()
+	// run go build on the main package
+	output, err := exec.Command("go", "build", packages[0]).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("error executing go build: %s\ngo build output:\n%s", err, string(output)), -4
+	}
+
+	return nil, 0
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	if len(flag.Args()) == 0 {
+		fmt.Println("missing arguments")
+		usage()
+		os.Exit(-1)
+	}
+
+	err, rv := multibuild(flag.Args())
 	if err != nil {
-		fmt.Print(string(output))
-		os.Exit(-4)
+		fmt.Println(err)
+		os.Exit(rv)
 	}
 }