func BenchmarkTBinaryRaw(b *testing.B) { b.StopTimer() s, clientFactory := SetupTrpc(b, thrift.NewTBinaryProtocolFactory(true, true)) defer s.Close() client := clientFactory() reqs := GetRandomTestReqs("compressed", b.N, 5, 50000) b.StartTimer() for _, req := range reqs { if res, err := client.GetValuesSingle(req); err != nil { b.Fatal("error: ", err) } else { b.StopTimer() CheckReqAndRes(b, req, res) b.StartTimer() } } }
func main() { log.Printf("Quiver version %s (built %s, %s).\n\n", version, buildTime, runtime.Version()) t := time.Now() graphite := report.Flag() args := readSettings() stats := report.NewRecorder(). EnableGCInfoCollection(). MaybeReportTo(graphite). RegisterHttp(). SetAsDefault() hostname, err := os.Hostname() if err != nil { hostname = "localhost" } registrations := new(Registrations) if Settings.discoveryPath != "" && !Settings.downloadOnly { registrations.Connect() defer registrations.Close() } configs := getCollectionConfig(args) log.Println("Loading collections...") cs, err := hfile.LoadCollections(configs, Settings.cachePath, Settings.downloadOnly, stats) if err != nil { log.Fatal(err) } if Settings.downloadOnly { stats.FlushNow() return } if Settings.bloom > 0 { beforeBloom := time.Now() for _, c := range cs.Collections { log.Println("Calculating bloom filter for", c.Name) c.CalculateBloom(float64(Settings.bloom) / 100) } stats.TimeSince("startup.bloom", beforeBloom) } log.Printf("Serving on http://%s:%d/ \n", hostname, Settings.port) http.Handle("/rpc/HFileService", WrapHttpRpcHandler(cs, stats)) admin := adminz.New() admin.KillfilePaths(adminz.Killfiles(Settings.port)) admin.Servicez(func() interface{} { return struct { Collections map[string]*hfile.Reader `json:"collections"` Impl string `json:"implementation"` QuiverVersion string `json:"quiver_version"` PackageVersion string `json:"package_version"` }{ cs.Collections, "quiver", version, Settings.packageVersion, } }) admin.OnPause(registrations.Leave) admin.OnResume(func() { if Settings.discoveryPath != "" { registrations.Join(hostname, Settings.discoveryPath, configs, 0) } }) http.HandleFunc("/hfilez", admin.ServicezHandler) http.HandleFunc("/", admin.ServicezHandler) http.HandleFunc("/debug/bloom/enable", func(w http.ResponseWriter, r *http.Request) { for _, c := range cs.Collections { c.EnableBloom() } }) http.HandleFunc("/debug/bloom/disable", func(w http.ResponseWriter, r *http.Request) { for _, c := range cs.Collections { c.DisableBloom() } }) http.HandleFunc("/debug/bloom/calc", func(w http.ResponseWriter, r *http.Request) { if falsePos, err := strconv.Atoi(r.URL.Query().Get("err")); err != nil { http.Error(w, err.Error(), 400) } else if falsePos > 99 || falsePos < 1 { http.Error(w, "`err` param must be a false pos rate between 0 and 100", 400) } else { admin.Pause() defer admin.Resume() for _, c := range cs.Collections { fmt.Fprintln(w, "Recalculating bloom for", c.Name) c.CalculateBloom(float64(falsePos) / 100) } } }) runtime.GC() stats.FlushNow() admin.Start() stats.TimeSince("startup.total", t) if Settings.rpcPort > 0 { s, err := NewTRpcServer(fmt.Sprintf(":%d", Settings.rpcPort), WrapProcessor(cs, stats), thrift.NewTBinaryProtocolFactory(true, true)) if err != nil { log.Fatalln("Could not open RPC port", Settings.rpcPort, err) } else { if err := s.Listen(); err != nil { log.Fatalln("Failed to listen on RPC port", err) } go func() { log.Fatalln(s.Serve()) }() log.Println("Listening for raw RPC on", Settings.rpcPort) } } log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", Settings.port), nil)) }