312 lines
6.9 KiB
Go
312 lines
6.9 KiB
Go
package influx
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"encoding/csv"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// line protocol, better to gzip and sort tags by key in lexicographic order
|
|
func (client *influxClient) writeLinesData(ctx context.Context, db string,
|
|
data []byte, compress bool) error {
|
|
|
|
if compress {
|
|
var buf bytes.Buffer
|
|
gz := gzip.NewWriter(&buf)
|
|
if _, err := gz.Write(data); err != nil {
|
|
return err
|
|
}
|
|
if err := gz.Close(); err != nil {
|
|
return err
|
|
}
|
|
data = buf.Bytes()
|
|
}
|
|
|
|
request, err := http.NewRequest(http.MethodPost,
|
|
client.url+"/write?db="+db, bytes.NewReader(data))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
request.Header.Set("Content-Type", "text/plain; charset=utf-8")
|
|
request.Header.Set("Authorization", "Token "+client.token)
|
|
request.Header.Set("Accept", "application/json")
|
|
if compress {
|
|
request.Header.Set("Content-Encoding", "gzip")
|
|
}
|
|
|
|
response, err := client.Do(request.WithContext(ctx))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer response.Body.Close()
|
|
|
|
// http.StatusNoContent is the expected response,
|
|
// 200,201,202,206,207,208
|
|
// but if we get these we should still accept it as delivered.
|
|
if response.StatusCode != http.StatusNoContent {
|
|
return fmt.Errorf("unexpected status code: %d", response.StatusCode)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// for influx json response data
|
|
type jsonResp struct {
|
|
Results []*result `json:"results"`
|
|
}
|
|
|
|
type result struct {
|
|
StatementID int `json:"statement_id"`
|
|
Series []*fields `json:"series"`
|
|
}
|
|
|
|
type fields struct {
|
|
Name string `json:"name"`
|
|
Column []string `json:"columns"`
|
|
Values [][]any `json:"values"`
|
|
}
|
|
|
|
// respType json/csv
|
|
// json_time:"2024-12-18T08:12:21.4735154Z"
|
|
// csv_time:"1734572793695885000"
|
|
func (client *influxClient) getTVsResp(ctx context.Context, reqData url.Values,
|
|
respType string) ([]TV, error) {
|
|
request, err := http.NewRequestWithContext(ctx, http.MethodGet,
|
|
client.url+"/query?"+reqData.Encode(), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
request.Header.Set("Content-Type", "application/json")
|
|
request.Header.Set("Authorization", "Token "+client.token)
|
|
if respType == "csv" {
|
|
request.Header.Set("Accept", "application/csv")
|
|
}
|
|
|
|
response, err := client.Do(request)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer response.Body.Close()
|
|
|
|
if response.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("unexpected status code: %d", response.StatusCode)
|
|
}
|
|
|
|
respData, err := io.ReadAll(response.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return respDataToTVs(respData, respType)
|
|
}
|
|
|
|
// respType json/csv
|
|
// json_time:"2024-12-18T08:12:21.4735154Z"
|
|
// csv_time:"1734572793695885000"
|
|
func (client *influxClient) getF2TVsResp(ctx context.Context, reqData url.Values,
|
|
respType string) (map[string][]TV, error) {
|
|
request, err := http.NewRequestWithContext(ctx, http.MethodGet,
|
|
client.url+"/query?"+reqData.Encode(), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
request.Header.Set("Content-Type", "application/json")
|
|
request.Header.Set("Authorization", "Token "+client.token)
|
|
if respType == "csv" {
|
|
request.Header.Set("Accept", "application/csv")
|
|
}
|
|
|
|
response, err := client.Do(request)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer response.Body.Close()
|
|
|
|
if response.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("unexpected status code: %d", response.StatusCode)
|
|
}
|
|
|
|
respData, err := io.ReadAll(response.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return respDataToF2TVs(respData, respType)
|
|
}
|
|
|
|
func respDataToTVs(respData []byte, respType string) ([]TV, error) {
|
|
switch respType {
|
|
case "json":
|
|
resp := new(jsonResp)
|
|
err := json.Unmarshal(respData, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(resp.Results) > 0 &&
|
|
len(resp.Results[0].Series) > 0 {
|
|
return convertJsonToTVs(resp.Results[0].Series[0].Values)
|
|
}
|
|
case "csv":
|
|
rows, err := csv.NewReader(strings.NewReader(string(respData))).ReadAll()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(rows) > 1 {
|
|
return convertCsvToTVs(rows[1:])
|
|
}
|
|
default:
|
|
return nil, errors.New("invalid response type")
|
|
}
|
|
|
|
return []TV{}, nil
|
|
}
|
|
|
|
func respDataToF2TVs(respData []byte, respType string) (map[string][]TV, error) {
|
|
switch respType {
|
|
case "json":
|
|
resp := new(jsonResp)
|
|
err := json.Unmarshal(respData, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(resp.Results) > 0 &&
|
|
len(resp.Results[0].Series) > 0 {
|
|
return convertJsonToF2TVs(resp.Results[0].Series[0].Column,
|
|
resp.Results[0].Series[0].Values)
|
|
}
|
|
case "csv":
|
|
rows, err := csv.NewReader(strings.NewReader(string(respData))).ReadAll()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(rows) > 1 {
|
|
return convertCsvToF2TVs(rows)
|
|
}
|
|
default:
|
|
return nil, errors.New("invalid response type")
|
|
}
|
|
|
|
return map[string][]TV{}, nil
|
|
}
|
|
|
|
// measure at different times
|
|
func convertJsonToTVs(data [][]any) ([]TV, error) {
|
|
ret := make([]TV, 0, len(data))
|
|
|
|
for _, row := range data {
|
|
if len(row) > 1 {
|
|
tstr, ok := (row[0]).(string)
|
|
if !ok {
|
|
return nil, errors.New("not expected data type")
|
|
}
|
|
t, err := time.Parse("2006-01-02T15:04:05.999999Z", tstr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
v, ok := (row[1]).(float64)
|
|
if !ok {
|
|
return nil, errors.New("not expected data type")
|
|
}
|
|
ret = append(ret, TV{
|
|
Time: t.UnixNano(),
|
|
Value: v,
|
|
})
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
// different measures at different times
|
|
func convertJsonToF2TVs(cols []string, data [][]any) (map[string][]TV, error) {
|
|
f2tvs := make(map[string][]TV)
|
|
|
|
for _, row := range data {
|
|
if len(row) > 1 {
|
|
tstr, ok := (row[0]).(string)
|
|
if !ok {
|
|
return nil, errors.New("not expected data type")
|
|
}
|
|
t, err := time.Parse("2006-01-02T15:04:05.999999Z", tstr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for i := 1; i < len(row); i++ {
|
|
v, ok := (row[i]).(float64)
|
|
if !ok {
|
|
return nil, errors.New("not expected data type")
|
|
}
|
|
f2tvs[cols[i]] = append(f2tvs[cols[i]], TV{
|
|
Time: t.UnixNano(),
|
|
Value: v,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return f2tvs, nil
|
|
}
|
|
|
|
// measure at different times
|
|
func convertCsvToTVs(data [][]string) ([]TV, error) {
|
|
ret := make([]TV, 0, len(data))
|
|
|
|
for _, row := range data {
|
|
if len(row) > 3 {
|
|
ns, err := strconv.ParseInt(row[2], 10, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
v, err := strconv.ParseFloat(row[3], 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ret = append(ret, TV{
|
|
Time: ns,
|
|
Value: v,
|
|
})
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
// different measures at different times
|
|
func convertCsvToF2TVs(data [][]string) (map[string][]TV, error) {
|
|
f2tvs := make(map[string][]TV)
|
|
|
|
for _, row := range data {
|
|
if len(row) > 3 {
|
|
ns, err := strconv.ParseInt(row[2], 10, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for i := 3; i < len(row); i++ {
|
|
v, err := strconv.ParseFloat(row[i], 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
f2tvs[data[0][i]] = append(f2tvs[data[0][i]], TV{
|
|
Time: ns,
|
|
Value: v,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return f2tvs, nil
|
|
}
|