func fsMapHandler() types.RequestHandler {
var fileHandler = http.FileServer(httpfs.New(mapfs.New(fsmap)))
return types.RequestHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
fileHandler.ServeHTTP(w, r)
})
}
func ExampleWalk() {
var fs http.FileSystem = httpfs.New(mapfs.New(map[string]string{
"zzz-last-file.txt": "It should be visited last.",
"a-file.txt": "It has stuff.",
"another-file.txt": "Also stuff.",
"folderA/entry-A.txt": "Alpha.",
"folderA/entry-B.txt": "Beta.",
}))
walkFn := func(path string, fi os.FileInfo, err error) error {
if err != nil {
log.Printf("can't stat file %s: %v\n", path, err)
return nil
}
fmt.Println(path)
return nil
}
err := vfsutil.Walk(fs, "/", walkFn)
if err != nil {
panic(err)
}
// Output:
// /
// /a-file.txt
// /another-file.txt
// /folderA
// /folderA/entry-A.txt
// /folderA/entry-B.txt
// /zzz-last-file.txt
}
func Example() {
fs0 := httpfs.New(mapfs.New(map[string]string{
"zzz-last-file.txt": "It should be visited last.",
"a-file.txt": "It has stuff.",
"another-file.txt": "Also stuff.",
"folderA/entry-A.txt": "Alpha.",
"folderA/entry-B.txt": "Beta.",
}))
fs1 := httpfs.New(mapfs.New(map[string]string{
"sample-file.txt": "This file compresses well. Blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah!",
"not-worth-compressing-file.txt": "Its normal contents are here.",
"folderA/file1.txt": "Stuff 1.",
"folderA/file2.txt": "Stuff 2.",
"folderB/folderC/file3.txt": "Stuff C-3.",
}))
fs := union.New(map[string]http.FileSystem{
"/fs0": fs0,
"/fs1": fs1,
})
err := vfsutil.Walk(fs, "/", walk)
if err != nil {
panic(err)
}
// Output:
// /
// /fs0
// /fs0/a-file.txt
// /fs0/another-file.txt
// /fs0/folderA
// /fs0/folderA/entry-A.txt
// /fs0/folderA/entry-B.txt
// /fs0/zzz-last-file.txt
// /fs1
// /fs1/folderA
// /fs1/folderA/file1.txt
// /fs1/folderA/file2.txt
// /fs1/folderB
// /fs1/folderB/folderC
// /fs1/folderB/folderC/file3.txt
// /fs1/not-worth-compressing-file.txt
// /fs1/sample-file.txt
}
func main() {
server, err := blog.NewServer(cfg)
if err != nil {
log.Fatal(err)
}
http.Handle("/", server)
http.Handle("/lib/godoc/", http.StripPrefix("/lib/godoc/",
http.FileServer(httpfs.New(mapfs.New(static.Files))),
))
log.Fatal(http.ListenAndServe(":3999", nil))
}
func main() {
log.SetOutput(os.Stderr)
port := flag.String("port", "8080", "server listening tcp port")
dbServer := flag.String("server", "localhost", "database server")
dbName := flag.String("db", "estia", "database name")
siteType := flag.String("type", "dir", "site path type zip or dir")
sitePath := flag.String("path", "wwwroot", "path containing site")
flag.Parse()
server = *dbServer
database = *dbName
db, err := mgo.Dial(server)
if err != nil {
log.Panic(err)
}
defer db.Close()
router := NewRouter()
if *siteType == "zip" {
rd, err := zip.OpenReader(*sitePath)
if err != nil {
log.Fatal(err)
}
fs := zipfs.New(rd, *sitePath)
router.PathPrefix("/").Handler(http.FileServer(httpfs.New(fs)))
} else {
router.PathPrefix("/").Handler(http.FileServer(http.Dir(*sitePath)))
}
withLog := handlers.LoggingHandler(os.Stdout, router)
withdb := WithDB(db, withLog)
withcors := handlers.CORS()(withdb)
withGz := handlers.CompressHandler(withcors)
log.Printf(
"%s\t%s",
"Server listening on ",
*port,
)
log.Fatal(http.ListenAndServeTLS(":"+*port, "cert.pem", "key.pem", context.ClearHandler(withGz)))
}
func LoadAssetFileSystem(root string, indexes bool) (*AssetFileSystem, error) {
fs := asset.Fs()
if asset.Error() != nil {
return nil, asset.Error()
}
if _, err := fs.Stat(root); err != nil {
return nil, err
}
return &AssetFileSystem{
FileSystem: httpfs.New(fs),
root: root,
indexes: indexes,
fs: fs,
}, nil
}
func main() {
var fs http.FileSystem = httpfs.New(mapfs.New(map[string]string{
"sample-file.txt": "This file compresses well. Blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah!",
"not-worth-compressing-file.txt": "Its normal contents are here.",
"folderA/file1.txt": "Stuff in /folderA/file1.txt.",
"folderA/file2.txt": "Stuff in /folderA/file2.txt.",
"folderB/folderC/file3.txt": "Stuff in /folderB/folderC/file3.txt.",
// TODO: Empty folder somehow?
//"folder-empty/": "",
}))
err := vfsgen.Generate(fs, vfsgen.Options{
Filename: "test_vfsdata_test.go",
PackageName: "test_test",
})
if err != nil {
log.Fatalln(err)
}
}
// NewPresentation returns a new Presentation from a corpus.
// It sets SearchResults to:
// [SearchResultDoc SearchResultCode SearchResultTxt].
func NewPresentation(c *Corpus) *Presentation {
if c == nil {
panic("nil Corpus")
}
p := &Presentation{
Corpus: c,
mux: http.NewServeMux(),
fileServer: http.FileServer(httpfs.New(c.fs)),
TabWidth: 4,
ShowExamples: true,
DeclLinks: true,
SearchResults: []SearchResultFunc{
(*Presentation).SearchResultDoc,
(*Presentation).SearchResultCode,
(*Presentation).SearchResultTxt,
},
}
p.cmdHandler = handlerServer{
p: p,
c: c,
pattern: "/cmd/",
fsRoot: "/src",
}
p.pkgHandler = handlerServer{
p: p,
c: c,
pattern: "/pkg/",
stripPrefix: "pkg/",
fsRoot: "/src",
exclude: []string{"/src/cmd"},
}
p.cmdHandler.registerWithMux(p.mux)
p.pkgHandler.registerWithMux(p.mux)
p.mux.HandleFunc("/", p.ServeFile)
p.mux.HandleFunc("/search", p.HandleSearch)
p.mux.HandleFunc("/opensearch.xml", p.serveSearchDesc)
return p
}
func Example() {
walk := func(path string, fi os.FileInfo, err error) error {
if err != nil {
log.Printf("can't stat file %s: %v\n", path, err)
return nil
}
fmt.Println(path)
return nil
}
fs := httpfs.New(mapfs.New(map[string]string{
"zzz-last-file.txt": "It should be visited last.",
"a-file.txt": "It has stuff.",
"another-file.txt": "Also stuff.",
"some-file.html": "<html>and stuff</html>",
"folderA/entry-A.txt": "Alpha.",
"folderA/entry-B.txt": "Beta.",
"folderA/main.go": "package main\n",
"folderA/folder-to-skip/many.txt": "Entire folder can be skipped.",
"folderA/folder-to-skip/files.txt": "Entire folder can be skipped.",
"folder-to-skip": "This is a file, not a folder, and shouldn't be skipped.",
}))
ignore := func(fi os.FileInfo, _ string) bool {
return pathpkg.Ext(fi.Name()) == ".go" || pathpkg.Ext(fi.Name()) == ".html" ||
(fi.IsDir() && fi.Name() == "folder-to-skip")
}
fs = filter.NewIgnore(fs, ignore)
err := vfsutil.Walk(fs, "/", walk)
if err != nil {
panic(err)
}
fmt.Println()
// This file should be filtered out, even if accessed directly.
_, err = fs.Open("/folderA/main.go")
fmt.Println("os.IsNotExist(err):", os.IsNotExist(err))
fmt.Println(err)
fmt.Println()
// This folder should be filtered out, even if accessed directly.
_, err = fs.Open("/folderA/folder-to-skip")
fmt.Println("os.IsNotExist(err):", os.IsNotExist(err))
fmt.Println(err)
fmt.Println()
// This file should not be filtered out.
f, err := fs.Open("/folder-to-skip")
if err != nil {
panic(err)
}
io.Copy(os.Stdout, f)
f.Close()
// Output:
// /
// /a-file.txt
// /another-file.txt
// /folder-to-skip
// /folderA
// /folderA/entry-A.txt
// /folderA/entry-B.txt
// /zzz-last-file.txt
//
// os.IsNotExist(err): true
// open /folderA/main.go: file does not exist
//
// os.IsNotExist(err): true
// open /folderA/folder-to-skip: file does not exist
//
// This is a file, not a folder, and shouldn't be skipped.
}
// NewServer constructs a new Server using the specified config.
func NewServer(cfg Config) (*Server, error) {
present.PlayEnabled = cfg.PlayEnabled
parse := func(fs vfs.FileSystem, t *template.Template, filenames ...string) (*template.Template, error) {
if t == nil {
t = template.New(filenames[0]).Funcs(funcMap)
} else {
t = t.Funcs(funcMap)
}
for _, name := range filenames {
data, err := vfs.ReadFile(fs, filepath.ToSlash(filepath.Join(cfg.TemplatePath, name)))
if err != nil {
return nil, err
}
if _, err := t.Parse(string(data)); err != nil {
return nil, err
}
}
return t, nil
}
s := &Server{cfg: cfg}
// Parse templates.
var err error
s.template.home, err = parse(s.cfg.RootFS, nil, "root.tmpl", "home.tmpl")
if err != nil {
return nil, err
}
s.template.index, err = parse(s.cfg.RootFS, nil, "root.tmpl", "index.tmpl")
if err != nil {
return nil, err
}
s.template.article, err = parse(s.cfg.RootFS, nil, "root.tmpl", "article.tmpl")
if err != nil {
return nil, err
}
s.template.doc, err = parse(s.cfg.RootFS, present.Template(), "doc.tmpl")
if err != nil {
return nil, err
}
// Load content.
err = s.loadDocs(s.cfg.ContentPath)
if err != nil {
return nil, err
}
err = s.renderAtomFeed()
if err != nil {
return nil, err
}
err = s.renderJSONFeed()
if err != nil {
return nil, err
}
// Set up content file server.
s.content = http.StripPrefix(s.cfg.BasePath, http.FileServer(
httpfs.New(getNameSpace(s.cfg.RootFS, s.cfg.ContentPath)),
))
return s, nil
}
// New returns a raw file server, that serves the given virtual file system without special handling of index.html.
func New(root vfs.FileSystem) http.Handler {
// TODO: Use vfs.FileSystem.
return &rawFileServer{httpfs.New(root)}
}
func fsMapHandler(fsmap map[string]string) http.HandlerFunc {
return func(wr http.ResponseWriter, req *http.Request) {
wr.Header().Add("Expires", time.Now().Add(time.Hour).Format(time.RFC1123))
http.FileServer(httpfs.New(mapfs.New(fsmap))).ServeHTTP(wr, req)
}
}