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 }