func main() {
logging.SetLogLevel(logging.Warn)
runtime.GOMAXPROCS(runtime.NumCPU())
cmdOptions, _, fset, err := querycmd.ParseArgs(os.Args[1:])
if err != nil {
logging.Fatalf("%v\n", err)
os.Exit(1)
} else if cmdOptions.Help || len(cmdOptions.OpType) < 1 {
usage(fset)
os.Exit(0)
}
config := c.SystemConfig.SectionConfig("queryport.client.", true)
client, err := qclient.NewGsiClient(cmdOptions.Server, config)
if err != nil {
logging.Fatalf("%v\n", err)
os.Exit(1)
}
if err = querycmd.HandleCommand(client, cmdOptions, false, os.Stdout); err != nil {
fmt.Fprintf(os.Stderr, "Error occured %v\n", err)
}
client.Close()
}
func main() {
logging.SetLogLevel(logging.Error)
runtime.GOMAXPROCS(runtime.NumCPU())
cmdOptions, args, fset, err := querycmd.ParseArgs(os.Args[1:])
if err != nil {
logging.Fatalf("%v", err)
os.Exit(0)
} else if cmdOptions.Help {
usage(fset)
os.Exit(0)
} else if len(args) < 1 {
logging.Fatalf("%v", "specify a command")
}
b, err := c.ConnectBucket(cmdOptions.Server, "default", "default")
if err != nil {
log.Fatal(err)
}
defer b.Close()
maxvb, err := c.MaxVbuckets(b)
if err != nil {
log.Fatal(err)
}
config := c.SystemConfig.SectionConfig("queryport.client.", true)
client, err := qclient.NewGsiClient(cmdOptions.Server, config)
if err != nil {
log.Fatal(err)
}
switch args[0] {
case "sanity":
err = doSanityTests(cmdOptions.Server, client)
if err != nil {
fmt.Fprintf(os.Stderr, "Error occured %v\n", err)
}
case "mb14786":
err = doMB14786(cmdOptions.Server, client)
if err != nil {
fmt.Fprintf(os.Stderr, "Error occured %v\n", err)
}
case "mb13339":
err = doMB13339(cmdOptions.Server, client)
if err != nil {
fmt.Fprintf(os.Stderr, "Error occured %v\n", err)
}
case "benchmark":
doBenchmark(cmdOptions.Server, "localhost:8101")
case "consistency":
doConsistency(cmdOptions.Server, maxvb, client)
}
client.Close()
}
func CreateClient(server, serviceAddr string) (*qc.GsiClient, error) {
config := c.SystemConfig.SectionConfig("queryport.client.", true)
client, err := qc.NewGsiClient(server, config)
if err != nil {
log.Printf("Error while creating gsi client: ", err)
return nil, err
}
return client, nil
}
func getSingletonClient(clusterURL string) (*qclient.GsiClient, error) {
muclient.Lock()
defer muclient.Unlock()
if singletonClient == nil {
l.Debugf("creating singleton for URL %v", clusterURL)
conf, err := c.GetSettingsConfig(c.SystemConfig)
if err != nil {
return nil, err
}
qconf := conf.SectionConfig("queryport.client.", true /*trim*/)
client, err := qclient.NewGsiClient(clusterURL, qconf)
if err != nil {
return nil, fmt.Errorf("in NewGsiClient(): %v", err)
}
singletonClient = client
}
return singletonClient, nil
}
func RunCommands(cluster string, cfg *Config, statsW io.Writer) (*Result, error) {
t0 := time.Now()
var result Result
var clients []*qclient.GsiClient
var jobQ chan *Job
var aggrQ chan *JobResult
var wg1, wg2 sync.WaitGroup
if len(cfg.LatencyBuckets) == 0 {
cfg.LatencyBuckets = defaultLatencyBuckets
}
config := c.SystemConfig.SectionConfig("queryport.client.", true)
config.SetValue("settings.poolSize", int(cfg.Concurrency))
client, err := qclient.NewGsiClient(cluster, config)
if err != nil {
return nil, err
}
defer client.Close()
indexes, err := client.Refresh()
if err != nil {
return nil, err
}
clients = make([]*qclient.GsiClient, cfg.Clients)
for i := 0; i < cfg.Clients; i++ {
c, err := qclient.NewGsiClient(cluster, config)
if err != nil {
return nil, err
}
defer c.Close()
clients[i] = c
}
jobQ = make(chan *Job, cfg.Concurrency*1000)
aggrQ = make(chan *JobResult, cfg.Concurrency*1000)
for i := 0; i < cfg.Concurrency; i++ {
wg1.Add(1)
go Worker(jobQ, clients[i%cfg.Clients], aggrQ, &wg1)
}
wg2.Add(1)
go ResultAggregator(aggrQ, statsW, &wg2)
for i, spec := range cfg.ScanSpecs {
if spec.Id == 0 {
spec.Id = uint64(i)
}
for _, index := range indexes {
if index.Definition.Bucket == spec.Bucket &&
index.Definition.Name == spec.Index {
spec.DefnId = uint64(index.Definition.DefnId)
}
}
hFn := func(v int64) string {
if v == math.MinInt64 {
return "0"
} else if v == math.MaxInt64 {
return "inf"
}
return fmt.Sprint(time.Nanosecond * time.Duration(v))
}
res := new(ScanResult)
res.ErrorCount = platform.NewAlignedUint64(0)
res.LatencyHisto.Init(cfg.LatencyBuckets, hFn)
res.Id = spec.Id
result.ScanResults = append(result.ScanResults, res)
}
// warming up GsiClient
for _, client := range clients {
for _, spec := range cfg.ScanSpecs {
job := &Job{spec: spec, result: nil}
RunJob(client, job, nil)
break
}
}
fmt.Println("GsiClients warmed up ...")
result.WarmupDuration = float64(time.Since(t0).Nanoseconds()) / float64(time.Second)
// Round robin scheduling of jobs
var allFinished bool
loop:
for {
allFinished = true
for i, spec := range cfg.ScanSpecs {
if iter := platform.LoadUint32(&spec.iteration); iter < spec.Repeat+1 {
j := &Job{
spec: spec,
result: result.ScanResults[i],
}
jobQ <- j
platform.AddUint32(&spec.iteration, 1)
allFinished = false
}
}
if allFinished {
break loop
}
}
close(jobQ)
wg1.Wait()
close(aggrQ)
wg2.Wait()
return &result, err
}