Пример #1
0
// Report statisfies the Statement Interface
func (i *InsertStatement) Report(s *ponyExpress.StoreFront) string {
	// Pull data via StoreFront client
	allData := s.GetStatementResults(i.StatementID, "write")

	if allData == nil || allData[0].Series == nil {
		log.Fatalf("No data returned for write report\n  Statement Name: %v\n  Statement ID: %v\n", i.Name, i.StatementID)
	}

	ir := &insertReport{
		name:    i.Name,
		columns: allData[0].Series[0].Columns,
		values:  allData[0].Series[0].Values,
	}

	responseTimes := responseTimes(ir.columns, ir.values)

	ir.percentile = percentile(responseTimes)
	ir.avgResponseTime = avgDuration(responseTimes)
	ir.stdDevResponseTime = stddevDuration(responseTimes)
	ir.pointsPerSecond = int(float64(i.Timestamp.Count) / i.runtime.Seconds())
	ir.numRetries = countRetries(ir.columns, ir.values)
	ir.successfulWrites = countSuccesses(ir.columns, ir.values)
	ir.avgRequestBytes = numberBytes(ir.columns, ir.values)

	return ir.String()
}
Пример #2
0
// Run statisfies the Statement Interface
func (i *GoStatement) Run(s *ponyExpress.StoreFront) {
	s.Add(1)
	go func() {
		i.Statement.Run(s)
		s.Done()
	}()
}
Пример #3
0
// Run statisfies the Statement Interface
func (i *QueryStatement) Run(s *ponyExpress.StoreFront) {

	// Set the tracer
	i.Tracer = ponyExpress.NewTracer(i.tags())

	vals := make(map[string]interface{})

	var point models.Point

	runtime := time.Now()

	for j := 0; j < i.Count; j++ {

		// If the query is a simple query, send it.
		if len(i.Args) == 0 {
			b := []byte(i.TemplateString)

			// Make the package
			p := ponyExpress.NewPackage(ponyExpress.Query, b, i.StatementID, i.Tracer)

			// Increment the tracer
			i.Tracer.Add(1)

			// Send the package
			s.SendPackage(p)

		} else {
			// Otherwise cherry pick field values from the commune?

			// TODO: Currently the program lock up here if s.GetPoint
			//       cannot return a value, which can happen.
			// Seee insert.go
			s.Lock()
			point = s.GetPoint(i.Name, s.Precision)
			s.Unlock()

			setMapValues(vals, point)

			// Set the template string with args from the commune
			b := []byte(fmt.Sprintf(i.TemplateString, setArgs(vals, i.Args)...))

			// Make the package
			p := ponyExpress.NewPackage(ponyExpress.Query, b, i.StatementID, i.Tracer)

			// Increment the tracer
			i.Tracer.Add(1)

			// Send the package
			s.SendPackage(p)

		}
	}

	// Wait for all operations to finish
	i.Tracer.Wait()

	// Stop time timer
	i.runtime = time.Since(runtime)
}
Пример #4
0
// Run statisfies the Statement Interface
func (i *InfluxqlStatement) Run(s *ponyExpress.StoreFront) {

	// Set the tracer
	i.Tracer = ponyExpress.NewTracer(i.tags())

	// Make the Package
	p := ponyExpress.NewPackage(ponyExpress.Query, []byte(i.Query), i.StatementID, i.Tracer)

	// Increment the tracer
	i.Tracer.Add(1)

	// Send the Package
	s.SendPackage(p)

	// Wait for all operations to finish
	i.Tracer.Wait()
}
Пример #5
0
// SetVars sets up the environment for InsertStatement to call it's Run function
func (i *InsertStatement) SetVars(s *ponyExpress.StoreFront) chan<- string {
	// Set the #series at 1 to start
	i.series = 1

	// Num series is the product of the cardinality of the tags
	for _, tmpl := range i.Templates[0:i.TagCount] {
		i.series *= tmpl.numSeries()
	}

	// make stringers from the templates
	i.stringers = i.Templates.Init(i.series)

	// Set the time function, keeps track of 'time' of the points being created
	i.time = i.Timestamp.Time(s.StartDate, i.series, s.Precision)

	// Set a commune on the StoreFront
	s.Lock()
	comCh := s.SetCommune(i.Name)
	s.Unlock()

	// Set the tracer
	i.Tracer = ponyExpress.NewTracer(i.tags())

	return comCh
}
Пример #6
0
// Report statisfies the Statement Interface
// No test coverage, fix
func (i *InfluxqlStatement) Report(s *ponyExpress.StoreFront) (out string) {
	allData := s.GetStatementResults(i.StatementID, "query")

	iqlr := &influxQlReport{
		statement: i.Query,
		columns:   allData[0].Series[0].Columns,
		values:    allData[0].Series[0].Values,
	}

	iqlr.responseTime = time.Duration(responseTimes(iqlr.columns, iqlr.values)[0].Value)

	switch countSuccesses(iqlr.columns, iqlr.values) {
	case 0:
		iqlr.success = false
	case 1:
		iqlr.success = true
	default:
		log.Fatal("Error fetching response for InfluxQL statement")
	}

	return iqlr.String()
}
Пример #7
0
// Report statisfies the Statement Interface
func (i *QueryStatement) Report(s *ponyExpress.StoreFront) string {
	// Pull data via StoreFront client
	allData := s.GetStatementResults(i.StatementID, "query")

	if len(allData) == 0 || allData[0].Series == nil {
		log.Fatalf("No data returned for query report\n  Statement Name: %v\n  Statement ID: %v\n", i.Name, i.StatementID)
	}

	qr := &queryReport{
		name:    i.Name,
		columns: allData[0].Series[0].Columns,
		values:  allData[0].Series[0].Values,
	}

	responseTimes := responseTimes(qr.columns, qr.values)

	qr.percentile = percentile(responseTimes)
	qr.avgResponseTime = avgDuration(responseTimes)
	qr.stdDevResponseTime = stddevDuration(responseTimes)
	qr.successfulReads = countSuccesses(qr.columns, qr.values)
	qr.responseBytes = numberBytes(qr.columns, qr.values)

	return qr.String()
}
Пример #8
0
// Run statisfies the Statement Interface
func (i *InsertStatement) Run(s *ponyExpress.StoreFront) {

	// Set variables on the InsertStatement and make the comCh
	comCh := i.SetVars(s)

	// TODO: Refactor to eleminate the ctr
	// Start the counter
	ctr := 0

	// Create the first bytes buffer
	buf := bytes.NewBuffer([]byte{})

	runtime := time.Now()

	for k := 0; k < i.Timestamp.Count; k++ {

		// Increment the counter. ctr == k + 1?
		ctr++

		// Make the point from the template string and the stringers
		point := fmt.Sprintf(i.TemplateString, i.stringers.Eval(i.time)...)

		// Add the string to the buffer
		buf.WriteString(point)
		// Add a newline char to seperate the points
		buf.WriteString("\n")

		// If len(batch) == batchSize then send it
		if ctr%s.BatchSize == 0 && ctr != 0 {
			b := buf.Bytes()
			// Trimming the trailing newline character
			b = b[0 : len(b)-1]

			// Create the package
			p := ponyExpress.NewPackage(ponyExpress.Write, b, i.StatementID, i.Tracer)

			// Use Tracer to wait for all operations to finish
			i.Tracer.Add(1)

			// Send the package
			s.SendPackage(p)

			// Reset the bytes Buffer
			temp := bytes.NewBuffer([]byte{})
			buf = temp
		}

		// TODO: Racy
		// Has to do with InsertStatement and QueryStatement communication
		if len(comCh) < cap(comCh) {
			select {
			case comCh <- point:
				break
			default:
				break
			}
		}

	}

	// If There are additional points remaining in the buffer send them before exiting
	if buf.Len() != 0 {
		b := buf.Bytes()
		// Trimming the trailing newline character
		b = b[0 : len(b)-1]

		// Create the package
		p := ponyExpress.NewPackage(ponyExpress.Write, b, i.StatementID, i.Tracer)

		// Use Tracer to wait for all operations to finish
		i.Tracer.Add(1)

		// Send the package
		s.SendPackage(p)
	}

	// Wait for all tracers to decrement
	i.Tracer.Wait()

	// Stop the timer
	i.runtime = time.Since(runtime)
}
Пример #9
0
// Run statisfies the Statement Interface
func (w *WaitStatement) Run(s *ponyExpress.StoreFront) {
	runtime := time.Now()
	s.Wait()
	w.runtime = time.Since(runtime)
}
Пример #10
0
// Run statisfies the Statement Interface
func (i *SetStatement) Run(s *ponyExpress.StoreFront) {

	// Set the Tracer
	i.Tracer = ponyExpress.NewTracer(make(map[string]string))

	// Create a new Directive
	d := ponyExpress.NewDirective(strings.ToLower(i.Var), strings.ToLower(i.Value), i.Tracer)

	switch d.Property {

	// Needs to be set on both StoreFront and ponyExpress
	// Set the write percison for points generated
	case "precision":
		s.Precision = d.Value

		// Increment the tracer
		i.Tracer.Add(1)
		s.SendDirective(d)

	// Lives on StoreFront
	// Set the date for the first point entered into the database
	case "startdate":
		s.Lock()
		s.StartDate = d.Value
		s.Unlock()

	// Lives on StoreFront
	// Set the BatchSize for writes
	case "batchsize":
		s.Lock()
		s.BatchSize = parseInt(d.Value)
		s.Unlock()

	// Lives on StoreFront
	// Reset the ResultsClient to have a new address
	case "resultsaddress":
		s.Lock()
		s.SetResultsClient(influx.HTTPConfig{Addr: fmt.Sprintf("http://%v/", d.Value)})
		s.Unlock()

	// TODO: Make TestName actually change the reporting DB
	// Lives on StoreFront
	// Set the TestName that controls reporting DB
	case "testname":
		s.Lock()
		s.TestName = d.Value
		s.Unlock()

	// All other variables live on ponyExpress
	default:
		// Increment the tracer
		i.Tracer.Add(1)
		s.SendDirective(d)
	}
	i.Tracer.Wait()
}