func BenchmarkStaticFileOverTCPNoMultiplex(b *testing.B) { b.StopTimer() fcgiMux := http.NewServeMux() fcgiMux.Handle("/static/", http.FileServer("_test/", "/static")) if err := createStaticTestFile(); err != nil { log.Print("Failed to create test file:", err) return } tcplisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("Listen error:", err) return } weblisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("net.Listen error:", err) return } url := "http://" + weblisten.Addr().String() + "/static/fcgi_test.html" handler, err := Handler([]Dialer{ NewDialer("tcp", tcplisten.Addr().String()), }) if err != nil { log.Print("Handler error:", err) return } http.Handle("/static/", handler) go http.Serve(tcplisten, fcgiMux) go http.Serve(weblisten, nil) b.StartTimer() log.Print("Loop starting...", b.N) for i := 0; i < b.N; i++ { response, _, err := http.Get(url) if err != nil { log.Print("http.Get error:", err) } if response == nil { log.Print("Nil response.") continue } if response.StatusCode != 200 { log.Print("Bad response status:", response.StatusCode) continue } if response != nil { _, err := ioutil.ReadAll(response.Body) if err != nil { log.Print("ioutil.ReadAll error:", err) break } response.Body.Close() // b.SetBytes(int64(len(body))) } } weblisten.Close() tcplisten.Close() removeStaticTestFile() }
func BenchmarkHelloWorldOverTCPNoMultiplex(b *testing.B) { b.StopTimer() fcgiMux := http.NewServeMux() fcgiMux.Handle("/hello/", http.HandlerFunc(func(conn http.ResponseWriter, req *http.Request) { conn.Write(helloWorldBytes) })) tcplisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("Listen error:", err) return } weblisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("net.Listen error:", err) return } url := "http://" + weblisten.Addr().String() + "/hello/" handler, err := Handler([]Dialer{ NewDialer("tcp", tcplisten.Addr().String()), }) if err != nil { log.Print("Handler error:", err) return } http.Handle("/hello/", handler) go http.Serve(tcplisten, fcgiMux) go http.Serve(weblisten, nil) b.StartTimer() log.Print("Loop starting...", b.N) for i := 0; i < b.N; i++ { response, _, err := http.Get(url) if err != nil { log.Print("http.Get error:", err) } if response == nil { log.Print("Nil response.") continue } if response.StatusCode != 200 { log.Print("Bad response status:", response.StatusCode) continue } body, err := ioutil.ReadAll(response.Body) if err != nil { log.Print("ioutil.ReadAll error:", err) break } response.Body.Close() b.SetBytes(int64(len(body))) } weblisten.Close() tcplisten.Close() removeStaticTestFile() }
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 listenAndServe(addr string, certFile string, keyFile string, caFile string) os.Error { config := &tls.Config{ Rand: rand.Reader, Time: time.Seconds, NextProtos: []string{"http/1.1"}, AuthenticateClient: true, CipherSuites: []uint16{tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA}, } rootCert, err := ioutil.ReadFile(caFile) if err != nil { return err } config.RootCAs = x509.NewCertPool() if !config.RootCAs.AppendCertsFromPEM(rootCert) { return os.NewError("Failed to add root certificate.") } config.Certificates = make([]tls.Certificate, 1) config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile) if err != nil { return err } conn, err := net.Listen("tcp", addr) if err != nil { return err } tlsListener := tls.NewListener(conn, config) return http.Serve(tlsListener, nil) }
// The Router application registers RPC listeners to accept from the initiators // then registers RPC clients to each of the external services it may call. func main() { var err os.Error // Pull in command line options or defaults if none given flag.Parse() f, err := os.OpenFile(*skylib.LogFileName, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) if err == nil { defer f.Close() log.SetOutput(f) } skylib.Setup("Watcher.Generic") // Change this to be more descriptive rpc.HandleHTTP() go monitorServices() portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port) l, e := net.Listen("tcp", portString) if e != nil { log.Fatal("listen error:", e) } log.Println("Starting server") http.Serve(l, nil) }
// At the moment, this can start more than one Server on the same // port, which could be a problem. func (self *RpcService) Serve(done chan bool) { portString := fmt.Sprintf("%s:%d", self.IPAddress, self.Port) log.Println(portString) l, e := net.Listen("tcp", portString) if e != nil { log.Fatal("listen error:", e) } defer l.Close() switch self.Protocol { default: rpc.HandleHTTP() // Seems safe to call multiple times, but must // that precede net.Listen()? log.Println("Starting http server") http.Serve(l, nil) case "json": log.Println("Starting jsonrpc server") for { conn, err := l.Accept() if err != nil { panic(err.String()) } jsonrpc.ServeConn(conn) } } done <- true // This may never occur. }
func (this *WebSocketListener) Listen() { http.Serve(this.listener, websocket.Handler(func(connection *websocket.Conn) { // The HTTP package creates the goroutine itself. No need for us to do it. // Set the RemoteAddr here because of Go Bug #1636 this.ConnectionHandler(this.ircd, connection, connection.Request.RemoteAddr) })) }
func main() { // Pull in command line options or defaults if none given flag.Parse() f, err := os.OpenFile(*skylib.LogFileName, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) if err == nil { defer f.Close() log.SetOutput(f) } skylib.Setup(sName) r := NewGetUserDataService() rpc.Register(r) rpc.HandleHTTP() portString := fmt.Sprintf("%s:%d", *skylib.BindIP, *skylib.Port) l, e := net.Listen("tcp", portString) if e != nil { log.Fatal("listen error:", e) } log.Println("Starting server") http.Serve(l, nil) }
func BenchmarkStaticFileOverHTTPWithMultiplex(b *testing.B) { b.StopTimer() var C = 50 // number of simultaneous clients http.Handle("/static/", http.FileServer("_test/", "/static")) if err := createStaticTestFile(); err != nil { log.Print("Failed to create test file:", err) return } weblisten, err := net.Listen("tcp", ":0") if err != nil { log.Print("net.Listen error:", err) return } url := "http://" + weblisten.Addr().String() + "/static/fcgi_test.html" 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() removeStaticTestFile() }
func main( ) { rpc.HandleHTTP(); l, _ := net.Listen("tcp", ":8089"); http.Serve(l, http.HandlerFunc( handleRequest ) ); }
func startHttpServer(addr string) (err os.Error) { httpPort, err := net.Listen("tcp", addr) if err != nil { return } go http.Serve(httpPort, nil) return }
func Serve(listener net.Listener) { http.HandleFunc("/", viewHtml) http.HandleFunc("/$stats.html", statsHtml) http.Handle("/$main.js", stringHandler{"application/javascript", main_js}) http.Handle("/$main.css", stringHandler{"text/css", main_css}) http.HandleFunc("/$events/", evServer) http.Serve(listener, nil) }
// rpc over HTTP func serveHTTP(addr string) { rpc.HandleHTTP() l, err := net.Listen("tcp", addr) if err != nil { log.Fatal(err) } http.Serve(l, nil) }
func RunServer(addr string) { self := new(Server).Init() rpc.Register(self) rpc.HandleHTTP() l, e := net.Listen("tcp", addr) if e != nil { log.Exit("listen error: ", e) } http.Serve(l, nil) }
//Starts the server func main() { md := NewMatrixDatabase() rpc.Register(md) rpc.HandleHTTP() l, e := net.Listen("tcp", ":1234") if e != nil { log.Fatal("listen error:", e) } http.Serve(l, nil) }
func main() { reg := NewReg() rpc.RegisterName(registry.Name, reg) rpc.HandleHTTP() l, e := net.Listen("tcp", ":"+strconv.Itoa(registry.Port)) if e != nil { log.Fatal("listen error:", e) } http.Serve(l, nil) }
func main() { arith := new(arith.Arith) rpc.Register(arith) rpc.HandleHTTP() l, e := net.Listen("tcp", ":1234") if e != nil { log.Exit("listen error: ", e) } http.Serve(l, nil) }
func server() { ps := new(ProcessStarter) rpc.Register(ps) rpc.HandleHTTP() l, e := net.Listen("tcp", ":1234") if e != nil { log.Exit("listen error:", e) } go http.Serve(l, nil) }
func startServer() { l, e := net.Listen("tcp", ":0") // any available address if e != nil { log.Exitf("net.Listen tcp :0 %v", e) } serverAddr = l.Addr().String() log.Stderr("Test WebSocket server listening on ", serverAddr) http.Handle("/echo", Handler(echoServer)) go http.Serve(l, nil) }
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 (s *Server) Serve() { if err := s.Listen(); err != nil { log.Fatalf("Listen error: %v", err) } go runTestHarnessIntegration(s.listener) err := http.Serve(s.listener, s) if err != nil { log.Printf("Error in http server: %v\n", err) os.Exit(1) } }
func main() { flag.Parse() t := &LunchTracker{NewPoll()} rpc.Register(t) rpc.HandleHTTP() l, e := net.Listen("tcp", ":"+strconv.Uitoa(*port)) if e != nil { log.Exit("listen error:", e) } http.Serve(l, nil) }
func Serve(listener net.Listener) { prefix := "/d/" + ClusterName evPrefix = "/events" + prefix http.Handle("/", http.RedirectHandler("/view/d/"+ClusterName+"/", 307)) http.HandleFunc("/view/", viewHtml) http.Handle("/main.js", stringHandler{"application/javascript", main_js}) http.Handle("/main.css", stringHandler{"text/css", main_css}) http.HandleFunc(evPrefix+"/", evServer) http.Serve(listener, nil) }
func main() { l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { fmt.Printf("%s\n", err) os.Exit(1) } fmt.Printf("%d\n", l.Addr().(*net.TCPAddr).Port) http.Handle("/", http.FileServer(http.Dir("."))) http.Serve(l, nil) }
func HttpClientSetupForTest(t *testing.T) (net.Listener, net.Addr) { addr, err := FindAvailableTCPServerPort(40000) if err != nil { t.Fatalf("Unable to find available tcp port addr: %s", err) } l, err := net.Listen(addr.Network(), addr.String()) if err != nil { t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err) } go http.Serve(l, &HTTPEchoServer{}) return l, addr }
// serveHTTP serves App Engine HTTP requests. func serveHTTP(netw, addr string) { if netw == "unix" { os.Remove(addr) } l, err := net.Listen(netw, addr) if err != nil { log.Fatal("appengine: ", err) } err = http.Serve(l, nil) if err != nil { log.Fatal("appengine: ", err) } }
// serveHTTP serves App Engine HTTP requests. func serveHTTP(netw, addr string) { if netw == "unix" { os.Remove(addr) } l, err := net.Listen(netw, addr) if err != nil { log.Fatal("appengine: ", err) } err = http.Serve(l, http.HandlerFunc(handleFilteredHTTP)) if err != nil { log.Fatal("appengine: ", err) } }
func init() { http.Handle("/", HandlerString("hello")) http.HandleFunc("/echo", echo) go func() { l, e := net.Listen("tcp", ":"+port) if e != nil { panic(e) } e = http.Serve(l, nil) l.Close() panic(e) }() }
func main() { opts := optparse.Parser("Usage: hubproxy [options]\n", "hubproxy 0.0.0") port := opts.Int([]string{"-p", "--port"}, 8010, "the port number to use [default: 8010]") host := opts.String([]string{"--host"}, "localhost", "the host to bind to") remote := opts.String([]string{"-r", "--remote"}, "ampcentral.appspot.com", "the remote host to connect to [default: ampcentral.appspot.com]") debug := opts.Bool([]string{"--debug"}, false, "enable debug mode") os.Args[0] = "hubproxy" args := opts.Parse(os.Args) if len(args) >= 1 { if args[0] == "help" { opts.PrintUsage() os.Exit(1) } } // Initialise the Ampify runtime -- which will run hubproxy on multiple // processors if possible. runtime.Init() // Initialise the TLS config. tlsconf.Init() debugMode = *debug remoteHost = *remote remoteAddr = *remote + ":443" addr := fmt.Sprintf("%s:%d", *host, *port) listener, err := net.Listen("tcp", addr) if err != nil { fmt.Printf("Cannot listen on %s: %v\n", addr, err) os.Exit(1) } fmt.Printf("Running hubproxy with %d CPUs on %s\n", runtime.CPUCount, addr) proxy := new(Proxy) http.Serve(listener, proxy) }
func main() { flag.Parse() httperf := new(HTTPerf) rpc.Register(httperf) rpc.HandleHTTP() l, e := net.Listen("tcp", fmt.Sprintf("%s:%d", *host, *port)) if e != nil { log.Fatalf("listen error:", e) } log.Printf("Now listening for requests on %s:%d", *host, *port) http.Serve(l, nil) }