nrsc

README

nrsc - Resource Compiler for Go

nrsc a directory of resource into a Go source file so you can still deploy a single executable as a web server with all the CSS, image files, JS ... included.

Installing

go get bitbucket.org/tebeka/nrsc
go get bitbucket.org/tebeka/nrsc/nrsc

(The 2'nd command will grab the nrsc executable)

And you'll need zip somewhere in your path.

Invocation

go build
nrsc <executable> <resource dir> [zip options]

API

The nrsc package has the following interface

nrsc.Handle(prefix string)

This will register with the net/http module to handle all paths starting with prefix.

When a request is handled, prefix is stripped and then a resource is located and served.

Resource that are not found will cause an HTTP 404 response.

nrsc.Get(path string) Resource

Will return a resource interface (or nil if not found) (see resource interface below).

This allows you more control on how to serve.

LoadTemplates(t *template.Template, filenames ...string) (*template.Template, error)

Will load named templates from resources. If the argument "t" is nil, it is created from the first resource.

Resource Interface

func Open() (io.Reader, error)

Returns a reader to resource data

func Size() int64

Returns resource size (to be used with Content-Length HTTP header).

func ModTime() time.Time

Returns modification time (to be used with Last-Modified HTTP header).

Example Code

package main

import (
        "fmt"
        "net/http"
        "os"

        "bitbucket.org/tebeka/nrsc"
)

func indexHandler(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, "Hello World\n")
}

func main() {
        nrsc.Handle("/static/")
        http.HandleFunc("/", indexHandler)
        if err := http.ListenAndServe(":8080", nil); err != nil {
                fmt.Fprintf(os.Stderr, "error: %s\n", err)
                os.Exit(1)
        }
}

Contact

https://bitbucket.org/tebeka/nrsc

License

MIT (see LICENSE.txt)

Documentation

Overview

Serving resource from zip file appended to Go executable (this enables on file deploy).

Making it happen:

1. Add code to serve resources (see example below)
2. Compile your executable
3. Run "nrsc /path/to/exe /path/to/resources"
4. Deploy

Example code:

package main

import (
	"fmt"
	"net/http"
	"os"

	"bitbucket.org/tebeka/nrsc"
)

type params struct {
	Number  int
}

func indexHandler(w http.ResponseWriter, req *http.Request) {
	t, err := nrsc.LoadTemplates(nil, "t.html")
	if err != nil {
		http.NotFound(w, req)
	}
	if err = t.Execute(w, params{7}); err != nil {
		http.NotFound(w, req)
	}
}

func main() {
	nrsc.Handle("/static/")
	nrsc.Mask(".tmpl$")
	http.HandleFunc("/", indexHandler)
	if err := http.ListenAndServe(":8080", nil); err != nil {
		fmt.Fprintf(os.Stderr, "error: %s\n", err)
		os.Exit(1)
	}
}

Index

• Constants
• Variables
• func Handle(prefix string) error
• func Initialize() error
• func LoadTemplates(t *template.Template, filenames ...string) (*template.Template, error)
• func Mask(mask *regexp.Regexp)
• type Resource
  • func Get(path string) Resource

Constants

const (
	Version = "0.4.1"
)

Variables

var ResourceMap map[string]Resource = nil

Functions

func Handle

func Handle(prefix string) error

Handle register HTTP handler under prefix

func Initialize

func Initialize() error

func LoadTemplates

func LoadTemplates(t *template.Template, filenames ...string) (*template.Template, error)

LoadTemplates loads named templates from resources. If the argument "t" is nil, it is created from the first resource.

func Mask

func Mask(mask *regexp.Regexp)

Mask masks URLs from being served (the HTTP server will return 401 Unauthorized)

Types

type Resource

type Resource interface {
	Name() string
	Open() (io.ReadCloser, error)
	Size() int64
	ModTime() time.Time
}

func Get

func Get(path string) Resource

Get returns the named resource (nil if not found)