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