Skip to content

File server

Gerasimos (Makis) Maropoulos edited this page Aug 11, 2019 · 8 revisions

Serve static files from a specific directory (system physical or embedded to the application) is done by the Party.HandleDir method.

HandleDir registers a handler that serves HTTP requests with the contents of a file system (physical or embedded).

  • First parameter : the route path
  • Second parameter : the system or the embedded directory that needs to be served
  • Third parameter : not required, the directory options, set fields is optional.

Returns the GET *Route.

HandleDir(requestPath, directory string, opts ...DirOptions) (getRoute *Route)

The DirOptions structure looks like this:

type DirOptions struct {
    // Defaults to "/index.html", if request path is ending with **/*/$IndexName
    // then it redirects to **/*(/) which another handler is handling it,
    // that another handler, called index handler, is auto-registered by the framework
    // if end developer wasn't managed to handle it manually/by hand.
    IndexName string
    // Should files served under gzip compression?
    Gzip bool

    // List the files inside the current requested directory if `IndexName` not found.
    ShowList bool
    // If `ShowList` is true then this function will be used instead
    // of the default one to show the list of files of a current requested directory(dir).
    DirList func(ctx iris.Context, dirName string, dir http.File) error

    // When embedded.
    Asset      func(name string) ([]byte, error)   
    AssetInfo  func(name string) (os.FileInfo, error)
    AssetNames func() []string

    // Optional validator that loops through each found requested resource.
    AssetValidator func(ctx iris.Context, name string) bool
}

Let's say that you have an ./assets folder near to your executable and you want the files to be served through http://localhost:8080/static/**/* route.

app := iris.New()

app.HandleDir("/static", "./assets")

app.Run(iris.Addr(":8080"))

Now, if you want to embed the static files to be lived inside the executable build in order to not depend on a system directory you can use a tool like go-bindata to convert the files into []byte inside your program. Let's take a quick tutorial on this and how Iris helps to serve those data.

Install go-bindata:

go get -u github.com/go-bindata/go-bindata/...

Navigate to your program directory, that the ./assets subdirectory exists and execute:

$ go-bindata ./assets/...

The above creates a generated go file which contains three main functions: Asset, AssetInfo and AssetNames. Use them on the DirOptions:

// [app := iris.New...]

app.HandleDir("/static", "./assets", iris.DirOptions {
    Asset: Asset,
    AssetInfo: AssetInfo,
    AssetNames: AssetNames,
    Gzip: false,
})

Build your app:

$ go build

The HandleDir supports all the standards, including content-range, for both physical and embedded directories.

However, if you just need a handler to work with, without register a route, you can use the iris.FileServer package-level function instead.

The FileServer function returns a Handler which serves files from a specific system, phyisical, directory or an embedded one.

  • First parameter: is the directory.
  • Second parameter: optional parameter is any optional settings that the caller can use.
iris.FileServer(directory string, options ...DirOptions)

Usage

handler := iris.FileServer("./assets", iris.DirOptions {
    ShowList: true, Gzip: true, IndexName: "index.html",
})

Examples can be found at: https://github.com/kataras/iris/tree/master/_examples/file-server

You can’t perform that action at this time.