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) } }