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