func TestSetValues(t *testing.T) { buf := &bytes.Buffer{} handler := weblogs.HandlerWithOptions( &handler{Field1: "one", Field2: "two"}, &weblogs.Options{Writer: buf, Logger: setLogger{}}) handler.ServeHTTP( kNilResponseWriter, newRequest("192.168.5.1", "GET", "/foo/bar?query=tall")) expected := "field1=one field2=two\n" verifyLogs(t, expected, buf.String()) }
func TestNormalLogs(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Status: 321, Clock: clock, ElapsedMillis: 387}, &weblogs.Options{Writer: buf, Now: clock.Now()}) handler.ServeHTTP( kNilResponseWriter, newRequest("192.168.5.1:3333", "GET", "/foo/bar?query=tall")) expected := "03/23/2013 13:14:15 192.168.5.1 GET /foo/bar?query=tall 321 387\n" verifyLogs(t, expected, buf.String()) }
func TestAppendedLogs(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Status: 321, LogExtra: "behere"}, &weblogs.Options{Writer: buf, Now: clock.Now()}) handler.ServeHTTP( kNilResponseWriter, newRequest("192.168.5.1", "GET", "/foo/bar?query=tall")) expected := "03/23/2013 13:14:15 192.168.5.1 GET /foo/bar?query=tall 321 0 behere\n" verifyLogs(t, expected, buf.String()) }
func TestSupportHijack(t *testing.T) { // test that loggers.Capture supports hijacking buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Clock: clock, Hijack: true}, &weblogs.Options{ Writer: buf, Logger: weblogs.ApacheCommonLogger(), Now: clock.Now()}) handler.ServeHTTP( kNilResponseWriter, newRequest("192.168.101.103:4444", "GET", "/bar/baz?query=short")) expected := "192.168.101.103 - - [23/Mar/2013:13:14:15 +0000] \"GET /bar/baz?query=short HTTP/1.0\" 0 0\n" verifyLogs(t, expected, buf.String()) }
func TestSend500OnNoOutput(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{LogExtra: "behere", Clock: clock, ElapsedMillis: 23}, &weblogs.Options{Writer: buf, Now: clock.Now()}) w := &spyResponseWriter{} handler.ServeHTTP( w, newRequest("192.168.5.1:3333", "GET", "/foo/bar?query=tall")) expected := "03/23/2013 13:14:15 192.168.5.1 GET /foo/bar?query=tall 500 23 behere\n" verifyLogs(t, expected, buf.String()) if w.Status != 500 { t.Errorf("Expected 500 error to be sent, but %d was sent.", w.Status) } }
func TestLogStatus200(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Message: "1234567"}, &weblogs.Options{ Writer: buf, Logger: weblogs.ApacheCommonLogger(), Now: clock.Now()}) request := newRequest("192.168.5.1:3333", "GET", "/foo/bar?query=tall") request.URL.User = url.User("fred") handler.ServeHTTP( kNilResponseWriter, request) expected := "192.168.5.1 - fred [23/Mar/2013:13:14:15 +0000] \"GET /foo/bar?query=tall HTTP/1.0\" 200 7\n" verifyLogs(t, expected, buf.String()) }
func main() { flag.Parse() if fDb == "" { fmt.Println("Need to specify at least -db flag.") flag.Usage() return } setupDb(fDb) mux := http.NewServeMux() http.HandleFunc("/", rootRedirect) http.Handle("/static/", http.StripPrefix("/static", static.New())) if fIcon != "" { err := http_util.AddStaticFromFile( http.DefaultServeMux, "/images/favicon.ico", fIcon) if err != nil { fmt.Printf("Icon file not found - %s\n", fIcon) } } http.Handle( "/auth/login", &login.Handler{SessionStore: kSessionStore, Store: kStore}) http.Handle( "/auth/poll", pollHandler{}) http.Handle( "/vsafe/", &authHandler{mux}) mux.Handle("/vsafe/chpasswd", &chpasswd.Handler{Store: kStore, Doer: kDoer}) mux.Handle("/vsafe/home", &home.Handler{Store: kStore}) mux.Handle("/vsafe/logout", &logout.Handler{}) mux.Handle("/vsafe/single", &single.Handler{Store: kStore, Doer: kDoer}) defaultHandler := context.ClearHandler( weblogs.HandlerWithOptions( http.DefaultServeMux, &weblogs.Options{Logger: logging.ApacheCommonLoggerWithLatency()})) if fSSLCrt != "" && fSSLKey != "" { if err := http.ListenAndServeTLS( fPort, fSSLCrt, fSSLKey, defaultHandler); err != nil { fmt.Println(err) } return } if err := http.ListenAndServe(fPort, defaultHandler); err != nil { fmt.Println(err) } }
func TestRaces(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Status: 200}, &weblogs.Options{ Writer: buf, Logger: verySimpleLogger{}, Now: clock.Now()}) var wg sync.WaitGroup wg.Add(20) for i := 0; i < 20; i++ { go func() { handler.ServeHTTP( kNilResponseWriter, newRequest("192.168.5.1:3333", "GET", "/foo/bar?query=tall")) wg.Done() }() } wg.Wait() }
func TestCombinedLogs(t *testing.T) { buf := &bytes.Buffer{} clock := &clock{Time: kTime} handler := weblogs.HandlerWithOptions( &handler{Status: 321, Message: "1234567"}, &weblogs.Options{ Writer: buf, Logger: weblogs.ApacheCombinedLogger(), Now: clock.Now()}) request := newRequest("192.168.5.1:3333", "GET", "/foo/bar?query=tall") request.URL.User = url.User("fred") request.Header = make(http.Header) request.Header.Set("Referer", "referer") request.Header.Set("User-Agent", "useragent") handler.ServeHTTP( kNilResponseWriter, request) expected := "192.168.5.1 - fred [23/Mar/2013:13:14:15 +0000] \"GET /foo/bar?query=tall HTTP/1.0\" 321 7 \"referer\" \"useragent\"\n" verifyLogs(t, expected, buf.String()) }
func main() { //SSH goroutine go func() { config := ssh.ServerConfig{ PublicKeyCallback: keyAuth, } config.AddHostKey(hostPrivateKeySigner) port := strconv.Itoa(hostSSHPort) socket, err := net.Listen("tcp", ":"+port) if err != nil { panic(err) } for { conn, err := socket.Accept() if err != nil { panic(err) } // From a standard TCP connection to an encrypted SSH connection sshConn, chans, reqs, err := ssh.NewServerConn(conn, &config) if err != nil { log.Println("Error accepting ssh connection: ", err) continue } log.Println("Connection from", sshConn.RemoteAddr()) // Print incoming out-of-band Requests go handleRequests(reqs) // Accept all channels go handleChannels(chans) } }() // // Garbage collecting goroutine // For testing, a stop-the-world gc using mutexes shall be 'nuff go func() { for { authRequestMap.Lock() for k, v := range authRequestMap.timestamps { killtime := time.Now().Add(-5 * time.Minute) if v.Before(killtime) { log.Debugf("Garbage collected key %s, %v old", k, time.Now().Sub(v)) delete(authRequestMap.timestamps, k) delete(authRequestMap.matches, k) } } authRequestMap.Unlock() time.Sleep(2 * time.Minute) } }() templateStart, err = template.New("index.html").ParseFiles("index.html") if err != nil { panic(err) } templateAuth, err = template.New("auth.html").ParseFiles("auth.html") if err != nil { panic(err) } http.HandleFunc("/auth", authRequestHandler) http.HandleFunc("/", startHandler) weblogOptions := &weblogs.Options{ Writer: nil, Logger: customLogger{}, } csrfHandler := nosurf.New(http.DefaultServeMux) csrfHandler.SetBaseCookie(http.Cookie{HttpOnly: true, Secure: sslEnabled}) handler := context.ClearHandler(weblogs.HandlerWithOptions(csrfHandler, weblogOptions)) if sslEnabled { go http.ListenAndServe(":"+strconv.Itoa(hostHTTPPort), handler) http.ListenAndServeTLS(":"+strconv.Itoa(hostTLSPort), sslCertPath, sslKeyPath, handler) } else { http.ListenAndServe(":"+strconv.Itoa(hostHTTPPort), handler) } }