The development setup described in Getting Started is a great way to get going with Vugu. But when you're ready to move your application to a staging or production environment (or you need to do development work on the Go server part of your web application), additional steps are in order.

Adding a Server

The server you created on the Getting Started page is only a single file, it does not compile as part of your application (due to the // +build ignore at the top). The main reason for this is that it makes things simpler when you are just hacking away on your user interface. If you enter bad code into a .vugu file (which ends up in a .go file and breaks your build), go run devserver.go will still run.

To make a proper server suitable for staging or production, or to start adding more server-side functionality to, you'll want to create a server.go file, and place separate web server code in here. It is suggested you leave devserver.go where it is and you can use it if/when needed, it won't conflict with server.go.

Note that server.go looks really similar to devserver.go in the beginning. But as you add server-side functionality other things to server.go, the need for it becomes more apparent. We also have some additional command line flags that are useful for an application running on a server.

This example includes a -dev flag to enable automatically performing Vugu code generation and rebuilding your wasm (same as devserver.go), which you can turn on and off. Running without -dev, this can also serve as a viable production server. (Obviously you need to be aware of your specific prouction environment requirements, but this will get you pointed in the right direction.)

Command line flags for the HTTP listener and the directory to look for files in are also included. server.go:

  1. // +build !wasm
  2.  
  3. package main
  4.  
  5. //go:generate vugugen .
  6.  
  7. import (
  8.     "flag"
  9.     "log"
  10.     "net/http"
  11.     "os"
  12.     "path/filepath"
  13.  
  14.     "github.com/vugu/vugu/simplehttp"
  15. )
  16.  
  17. func main() {
  18.     dev := flag.Bool("dev", false, "Enable development features")
  19.     dir := flag.String("dir", ".", "Project directory")
  20.     httpl := flag.String("http", "127.0.0.1:8877", "Listen for HTTP on this host:port")
  21.     flag.Parse()
  22.     wd, _ := filepath.Abs(*dir)
  23.     os.Chdir(wd)
  24.     log.Printf("Starting HTTP Server at %q", *httpl)
  25.     h := simplehttp.New(wd, *dev)
  26.     log.Fatal(http.ListenAndServe(*httpl, h))
  27. }

To run this server, you can either build the binary and run it directly, or go run . -dev also works.

Making dist.go

Rather than introducing third party build tools, the suggested approach to distributing your application is to create a small file called dist.go (ignored by the rest of your application) that you run when you want to build your distribution. The distutil package has some convient functions that make this less tedious than it might seem. This approach also has the advantage that it works equally well on Windows, Linux and Mac, and without having to install anything. The Go module system takes care of that for you.

Various steps are possible and there is not a one-size-fits-all dist.go. That said, here's one that will get you started:

  • It creates a "dist" folder, copies the static files from your project into it
  • It finds and copies wasm_exec.js
  • It makes sure vugugen is installed
  • It runs go generate
  • It builds your main.wasm file
  • And if desired you can make it write out an index.html or build your server executable
  1. // +build ignore
  2.  
  3. package main
  4.  
  5. import (
  6.     "flag"
  7.     "fmt"
  8.     "log"
  9.     "os"
  10.     "os/exec"
  11.     "path/filepath"
  12.     "time"
  13.  
  14.     "github.com/vugu/vugu/distutil"
  15. )
  16.  
  17. func main() {
  18.  
  19.     clean := flag.Bool("clean", false, "Remove dist dir before starting")
  20.     dist := flag.String("dist", "dist", "Directory to put distribution files in")
  21.     flag.Parse()
  22.  
  23.     start := time.Now()
  24.  
  25.     if *clean {
  26.         os.RemoveAll(*dist)
  27.     }
  28.  
  29.     os.MkdirAll(*dist, 0755) // create dist dir if not there
  30.  
  31.     // copy static files
  32.     distutil.MustCopyDirFiltered(".", *dist, nil)
  33.  
  34.     // find and copy wasm_exec.js
  35.     distutil.MustCopyFile(distutil.MustWasmExecJsPath(), filepath.Join(*dist, "wasm_exec.js"))
  36.  
  37.     // check for vugugen and go get if not there
  38.     if _, err := exec.LookPath("vugugen"); err != nil {
  39.         fmt.Sprint(distutil.MustExec("go", "get", "github.com/vugu/vugu/cmd/vugugen"))
  40.     }
  41.  
  42.     // run go generate
  43.     fmt.Sprint(distutil.MustExec("go", "generate", "."))
  44.  
  45.     // run go build for wasm binary
  46.     fmt.Sprint(distutil.MustEnvExec([]string{"GOOS=js", "GOARCH=wasm"}, "go", "build", "-o", filepath.Join(*dist, "main.wasm"), "."))
  47.  
  48.     // STATIC INDEX FILE:
  49.     // if you are hosting with a static file server or CDN, you can write out the default index.html from simplehttp
  50.     // req, _ := http.NewRequest("GET", "/index.html", nil)
  51.     // outf, err := os.OpenFile(filepath.Join(*dist, "index.html"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
  52.     // distutil.Must(err)
  53.     // defer outf.Close()
  54.     // template.Must(template.New("_page_").Parse(simplehttp.DefaultPageTemplateSource)).Execute(outf, map[string]interface{}{"Request": req})
  55.  
  56.     // BUILD GO SERVER:
  57.     // or if you are deploying a Go server (yay!) you can build that binary here
  58.     // fmt.Sprint(distutil.MustExec("go", "build", "-o", filepath.Join(*dist, "server"), "."))
  59.  
  60.     log.Printf("dist.go complete in %v", time.Since(start))
  61. }

By dropping the above is dist.go and tuning it, you can run go run dist.go and get a dist folder with the distribution of your project, ready for deployment. And you can of course easily call this from another build/distribution system, such as a Dockerfile.