func main() { err := loadTemplates() if err != nil { fmt.Println(err) return } homepage = "<a href=\"/sim/10/1/1\">Basic Simulation</a><br /><table><tr><td>SpawnTime</td><td>10 mins</tr><tr><td># Nurses</td><td>1</td></tr><tr><td># Doctors</td><td>1</td></tr></table>" // Simulation wd, err := os.Getwd() if err != nil { log.Println("ERROR: Failed to get Working Directory", err) return } //indexHtml, err := ioutil.ReadFile(wd + "/assets/index.html") //if err != nil { fmt.Println("ERROR:", err); return; } http.Handle("/assets/", http.FileServer(wd, "")) http.HandleFunc("/sim/", http.HandlerFunc(SimulationHandler)) http.HandleFunc("/", http.HandlerFunc(HomeHandler)) err = http.ListenAndServe(":6060", nil) log.Println("LOG: Server Shutting Down") if err != nil { log.Println("ERROR:", err) } }
func init() { fmt.Println("Selog filekkkk") http.Handle("/index", http.HandlerFunc(Render)) http.Handle("/index.ghtml", http.HandlerFunc(RenderGoPagesForbidden)) http.Handle("/", http.HandlerFunc(func(conn http.ResponseWriter, request *http.Request) { if request.URL.Path == "/" { defaultPage := "index" if strings.TrimSpace(defaultPage) != "" { http.Redirect(conn, defaultPage, 307) } return } val := "src" + request.URL.Path input, err := os.OpenFile(val, os.O_RDONLY, 0666) // input,err := os.Open(val) if err != nil { conn.WriteHeader(404) conn.Write([]byte("<h1>404 Not Found</h1>")) return } s, _ := input.Stat() conn.Header.Set("Content-Length", fmt.Sprintf("%d(MISSING)", s.Size)) // conn.SetHeader("Content-Type", mime.TypeByExtension(strings.ToLower(path.Ext(val)))) fmt.Sprintf("%d(MISSING)", s.Size) mime.TypeByExtension(strings.ToLower(path.Ext(val))) conn.WriteHeader(200) http.ServeFile(conn, request, val) })) http.Handle("/src", http.HandlerFunc(RenderGoPagesForbidden)) http.Handle("/pages", http.HandlerFunc(RenderGoPagesForbidden)) }
func main() { flag.Parse() runtime.GOMAXPROCS(*threads) http.Handle("/pprof/cmdline", http.HandlerFunc(pprof.Cmdline)) http.Handle("/pprof/heap", http.HandlerFunc(pprof.Heap)) http.Handle("/pprof/symbol", http.HandlerFunc(pprof.Symbol)) go func() { http.ListenAndServe("0.0.0.0:6060", nil) }() if *accesslog != "" { logf, err := os.OpenFile(*accesslog, os.O_APPEND|os.O_RDWR|os.O_CREATE, 0644) if err != nil { log.Print("open " + *accesslog + " failed") return } memcache.AccessLog = log.New(logf, "", log.Ldate|log.Ltime) } else if *debug { memcache.AccessLog = log.New(os.Stdout, "", log.Ldate|log.Ltime) } tbefore := int64(0) if *before != "" { t, err := time.Parse(time.RFC3339[:len(*before)], *before) if err != nil { log.Print("parse time error", err.String()) return } t.ZoneOffset = 8 * 60 * 60 tbefore = t.Seconds() log.Print("load data before", t.Format(time.RFC3339)) } log.Print("start to open db ", *dbpath) store := NewStore(*dbpath, *dbdepth, tbefore) defer store.Close() addr := fmt.Sprintf("%s:%d", *listen, *port) s := memcache.NewServer(store) e := s.Listen(addr) if e != nil { log.Print("Listen at ", *listen, "failed") return } // monitor mem usage go func() { ul := uint64(*memlimit) * 1024 * 1024 for runtime.MemStats.HeapSys < ul { time.Sleep(1e9) } log.Print("Mem used by Go is over limitation ", runtime.MemStats.HeapSys/1024/1024, *memlimit) s.Shutdown() }() s.Serve() log.Print("shut down gracefully.") }
func main() { http.Handle("/admin", http.HandlerFunc(admin)) http.Handle("/banana", http.HandlerFunc(banana)) err := http.ListenAndServe(":11118", nil) if err != nil { panic("ListenAndServe: ", err.String()) } }
func main() { fmt.Printf("Starting http Server ... ") http.Handle("/args", http.HandlerFunc(ArgServer)) http.Handle("/hello", http.HandlerFunc(sayHello)) http.Handle("/sine", http.HandlerFunc(sineServer)) err := http.ListenAndServe("0.0.0.0:8080", nil) if err != nil { fmt.Printf("ListenAndServe Error :" + err.String()) } }
func main() { http.Handle("/blog", http.HandlerFunc(views.Index)) http.Handle("/blog/entry/add", http.HandlerFunc(views.AddEntry)) http.Handle("/blog/entry/", http.HandlerFunc(views.Entry)) http.Handle("/blog/comment/add", http.HandlerFunc(views.AddComment)) err := http.ListenAndServe(":12345", nil) if err != nil { panic("ListenAndServe: ", err.String()) } }
func main() { flag.Parse() http.Handle("/circle/", http.HandlerFunc(circle)) http.Handle("/rect/", http.HandlerFunc(rect)) http.Handle("/arc/", http.HandlerFunc(arc)) http.Handle("/text/", http.HandlerFunc(text)) err := http.ListenAndServe(*port, nil) if err != nil { log.Println("ListenAndServe:", err) } }
func Run(addr string) { // Configure the delimiters // Parse the file once statsTempl.SetDelims("<?", "?>") statsTempl.ParseFile(statsTemplatePath) http.Handle("/stats", http.HandlerFunc(Stats)) http.Handle("/add/", http.HandlerFunc(Add)) err := http.ListenAndServe(addr, nil) if err != nil { log.Fatal("ListenAndServe:", err) } }
/** * Main Function */ func main() { fmt.Printf("Starting http Server ... \n") http.Handle("/$sys", http.HandlerFunc(handleSys)) http.Handle("/$db", http.HandlerFunc(handleDb)) //internal webserver should be disabled http.Handle("/", http.FileServer(http.Dir("web/"))) err := http.ListenAndServe("127.0.0.1:8080", nil) if err != nil { fmt.Printf("ListenAndServe Error :" + err.String()) } }
func Start(ch *chan int, st *State.State) { world = *ch state = st go http.ListenAndServe(":25560", http.HandlerFunc(httpServe)) go http.ListenAndServe(":25561", websocket.Handler(wssServe)) // os.ForkExec("http://localhost:25560/index.oc", []string{}, []string{}, "", []*os.File{}) }
func main() { http.Handle("/", http.HandlerFunc(PushServer)) err := http.ListenAndServe(":12345", nil) if err != nil { panic("ListenAndServe: ", err.String()) } }
func main() { if len(os.Args) > 1 { upass = os.Args[1] } t := time.UTC() initend = isodatestring(t) initbegin = isodatestring(time.SecondsToUTC(t.Seconds() - (secondsPerDay * maxDays))) showparams("init") http.Handle("/users/", http.HandlerFunc(tfusers)) http.Handle("/list/", http.HandlerFunc(tflist)) err := http.ListenAndServe(":1958", nil) if err != nil { panic("ListenAndServe: ", err.String()) } }
func serveTestFiles(t *testing.T) (l net.Listener, err os.Error) { foundValidPort := false var port_str string for !foundValidPort { port := (rand.Int() & 0x7FFF) + 0x08000 port_str = strconv.Itoa(port) addr, err := net.ResolveTCPAddr("127.0.0.1:" + port_str) if err != nil { t.Error("Create TCP Address: ", err.String()) return nil, err } l, err = net.ListenTCP("tcp4", addr) if err != nil { if err == os.EADDRINUSE || strings.LastIndex(err.String(), os.EADDRINUSE.String()) != -1 { continue } t.Error("Unable to listen on TCP port: ", err.String()) return l, err } foundValidPort = true } OverrideRapleafHostPort("127.0.0.1", port_str) go http.Serve(l, http.HandlerFunc(ServeTestHTTP)) return l, err }
func view(prefix string) http.Handler { f := func(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) p := r.URL.Path[len(prefix):] if p == "" { p = "index" } s := new(Page) k := datastore.NewKey(c, "string", p, 0, nil) if item, err := memcache.Get(c, p); err == memcache.ErrCacheMiss { datastore.Get(c, k, s) err = memcache.Set(c, &memcache.Item{Key: p, Value: []byte(s.Content)}) if err != nil { panic(err) } } else if err != nil { panic(err) } else { s.Content = string(item.Value) } output := string(blackfriday.MarkdownCommon([]byte(s.Content))) viewTemplate.Execute(w, Foo{p, output, ""}) } return http.HandlerFunc(f) }
func (c *WsHttpCore) RegisterWsHttpHandler(id string, pattern string, methods []string) os.Error { if c.lookupConn(id) == nil { log.Println("Connection not found!", id) return os.NewError("connection not found") } if strings.HasPrefix(pattern, "/meta/wsconnections") { log.Println("Request to get async notifications about connections") c.AddConnectionListener(c.lookupConn(id), id) //c.DispatchResponse([]byte("true"),nil,connid,r.Id) // } return nil } handler := getHandlerFor(pattern, c.mux) fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { rsp, err := c.SendReceive(id, r) if err != nil { w.WriteHeader(500) log.Println(pattern, "handling error", err) return } w.Write(rsp) return }) for _, meth := range methods { handler.Add(meth, id, fn) } c.onDisconnect(id, func() { handler.RemoveAll(id, []string{}) }) log.Println("RegisterWsHttpHandler done") return nil }
// where prefix is like "/" or "/s3/" for e.g. "/camli/" or "/s3/camli/*" func makeCamliHandler(prefix, baseURL string, storage blobserver.Storage) http.Handler { if !strings.HasSuffix(prefix, "/") { panic("expected prefix to end in slash") } baseURL = strings.TrimRight(baseURL, "/") storageConfig := &storageAndConfig{ storage, &blobserver.Config{ Writable: true, Readable: true, IsQueue: false, URLBase: baseURL + prefix[:len(prefix)-1], }, } return http.HandlerFunc(func(conn http.ResponseWriter, req *http.Request) { action, err := parseCamliPath(req.URL.Path[len(prefix)-1:]) if err != nil { log.Printf("Invalid request for method %q, path %q", req.Method, req.URL.Path) unsupportedHandler(conn, req) return } handleCamliUsingStorage(conn, req, action, storageConfig) }) }
func (s *S) SetUpSuite(c *gocheck.C) { go func() { http.Handle("/html.html", http.HandlerFunc(htmlHandler)) http.Handle("/bin.bin", http.HandlerFunc(binHandler)) http.Handle("/post", http.HandlerFunc(postHandler)) http.Handle("/404.html", http.NotFoundHandler()) http.Handle("/cookie.html", http.HandlerFunc(cookieHandler)) http.Handle("/redirect/", http.HandlerFunc(redirectHandler)) fmt.Printf("\nRunning test server on http://localhost:54123\n") if err := http.ListenAndServe(":54123", nil); err != nil { c.Fatalf("Cannot run test server on port: %s", err.String()) } }() time.Sleep(2e8) c.Succeed() }
func main( ) { rpc.HandleHTTP(); l, _ := net.Listen("tcp", ":8089"); http.Serve(l, http.HandlerFunc( handleRequest ) ); }
func main() { fmt.Printf("http://localhost:1978/hello\n") http.Handle("/hello", http.HandlerFunc(HelloServer)) err := http.ListenAndServe(":1978", nil) if err != nil { panic("ListenAndServe: ", err.String()) } }
func main() { flag.Parse() http.Handle("/", http.HandlerFunc(QR)) err := http.ListenAndServe(*addr, nil) if err != nil { log.Fatal("ListenAndServe:", err) } }
//runs the web application and serves http requests func Run(addr string) { http.Handle("/", http.HandlerFunc(httpHandler)) log.Stdoutf("web.go serving %s", addr) err := http.ListenAndServe(addr, nil) if err != nil { log.Exit("ListenAndServe:", err) } }
func main() { log.Println("Starting up") flag.Parse() streamHost = fmt.Sprintf("scribe-%s.local.yelpcorp.com:3535", *aggregator) log.Println("Connecting to ", streamHost) go listenTCPClients() http.Handle("/", http.HandlerFunc(ServePage)) http.Handle("/lookup", http.HandlerFunc(ServeDataItemPage)) http.Handle("/ws", websocket.Handler(ServeWS)) err := http.ListenAndServe(":8080", nil) if err != nil { panic("ListenAndServe: " + err.String()) } }
func http_main() { //Process the http commands fmt.Printf("Starting http Server ... ") http.Handle("/", http.HandlerFunc(sayHello)) err := http.ListenAndServe("0.0.0.0:8080", nil) if err != nil { fmt.Printf("ListenAndServe Error", err) } }
func main() { req_channel = make(chan CRequest); go CHelloServer(req_channel); http.Handle("/hello", http.HandlerFunc(HelloServer)); err := http.ListenAndServe(":12345", nil); if err != nil { panic("ListenAndServe: ", err.String()) } }
func main() { flag.Parse() fmt.Println("Hello, world") http.Handle("/", handlerWrapper(http.HandlerFunc(testpage))) err := http.ListenAndServe(*addr, nil) if err != nil { fmt.Println("Oh noes.") } }
func registerRequestHandlers() { http.Handle("/marvin/coins/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/registration/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/unregister/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/messages/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/scores/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/achievements/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/marvin/leaderboard/", http.HandlerFunc(genericHttpPostRequestHandler)) http.Handle("/", http.HandlerFunc(genericInvalidRequestHandler)) }
func BenchmarkHelloWorldOverHTTPWithMultiplex(b *testing.B) { b.StopTimer() var C = 50 // number of simultaneous clients http.Handle("/hello/", http.HandlerFunc(func(conn http.ResponseWriter, req *http.Request) { conn.Write(helloWorldBytes) })) weblisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("net.Listen error:", err) return } url := "http://" + weblisten.Addr().String() + "/hello/" go http.Serve(weblisten, nil) // allow this many simultaneous connections to the webserver start := make(chan bool, C) for i := 0; i < C; i++ { start <- true } done := make(chan bool, b.N) // for syncing all the multiplex goroutines b.StartTimer() log.Print("Loop starting...", b.N) for i := 0; i < b.N; i++ { go func(index int) { <-start defer func() { done <- true start <- true }() response, _, err := http.Get(url) if err != nil { log.Print("http.Get error:", err) } if response == nil { log.Print("Nil response.") return } if response.StatusCode != 200 { log.Print("Bad response status:", response.StatusCode) return } if response != nil { body, err := ioutil.ReadAll(response.Body) if err != nil { log.Print("ioutil.ReadAll error:", err) return } b.SetBytes(int64(len(body))) response.Body.Close() } }(i) } for i := 0; i < b.N; i++ { <-done } weblisten.Close() }
func startAllServers(t *testing.T) (tcplisten, unixlisten, weblisten net.Listener) { var fcgiMux = http.NewServeMux() // define the muxer for the FCGI responders to use fcgiMux.Handle("/hello/", http.HandlerFunc(HelloServer)) fcgiMux.Handle("/notfound/", http.HandlerFunc(http.NotFound)) fcgiMux.Handle("/connection/", http.HandlerFunc(func(conn http.ResponseWriter, req *http.Request) { conn.SetHeader("Connection", "keep-alive") io.WriteString(conn, "connection test") })) fcgiMux.Handle("/static/", http.FileServer("_test", "/static")) if err := createStaticTestFile(); err != nil { t.Fatal(err) return } // then start the responders tcplisten, _ = net.Listen("tcp", ":0") go Serve(tcplisten, fcgiMux) unixlisten, _ = net.Listen("unix", "_test/unixsocket") go Serve(unixlisten, fcgiMux) // define the muxer for the http server to use // (all requests go to the pool of listeners) wd, _ := os.Getwd() handler, err := Handler([]Dialer{ NewDialer("tcp", tcplisten.Addr().String()), NewDialer("unix", unixlisten.Addr().String()), NewDialer("exec", wd+"/_test/listener_test_exec.out"), }) if err != nil { t.Fatal(err) return } webMux := http.NewServeMux() webMux.Handle("/", handler) // start the web server weblisten, _ = net.Listen("tcp", ":0") go http.Serve(weblisten, webMux) // return all the data return tcplisten, unixlisten, weblisten }
func main() { flag.Parse() // The counter is published as a variable directly. ctr := new(Counter) http.Handle("/counter", ctr) expvar.Publish("counter", ctr) http.Handle("/", http.HandlerFunc(Logger)) http.Handle("/go/", http.FileServer(*webroot, "/go/")) http.Handle("/flags", http.HandlerFunc(FlagServer)) http.Handle("/args", http.HandlerFunc(ArgServer)) http.Handle("/go/hello", http.HandlerFunc(HelloServer)) http.Handle("/chan", ChanCreate()) http.Handle("/date", http.HandlerFunc(DateServer)) err := http.ListenAndServe(":12345", nil) if err != nil { log.Panicln("ListenAndServe:", err) } }
//Runs the web application and serves http requests func (s *Server) Run(addr string) { s.initServer() mux := http.NewServeMux() mux.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline)) mux.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile)) mux.Handle("/debug/pprof/heap", http.HandlerFunc(pprof.Heap)) mux.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol)) mux.Handle("/", s) s.Logger.Printf("web.go serving %s\n", addr) l, err := net.Listen("tcp", addr) if err != nil { log.Fatal("ListenAndServe:", err) } s.l = l err = http.Serve(s.l, mux) s.l.Close() }