Merge branch 'master' into folder_by_uid

Author: julienduchesne

client.go

@@ -62,13 +62,16 @@ func New(baseURL string, cfg Config) (*Client, error) {
 }
 
 func (c *Client) request(method, requestPath string, query url.Values, body io.Reader, responseStruct interface{}) error {
-	var resp *http.Response
-	var err error
-	var bodyContents []byte
+	var (
+		req          *http.Request
+		resp         *http.Response
+		err          error
+		bodyContents []byte
+	)
 
 	// retry logic
 	for n := 0; n <= c.config.NumRetries; n++ {
-		r, err := c.newRequest(method, requestPath, query, body)
+		req, err = c.newRequest(method, requestPath, query, body)
 		if err != nil {
 			return err
 		}
@@ -78,7 +81,7 @@ func (c *Client) request(method, requestPath string, query url.Values, body io.R
 			time.Sleep(time.Second * 5)
 		}
 
-		resp, err = c.client.Do(r)
+		resp, err = c.client.Do(req)
 
 		// If err is not nil, retry again
 		// That's either caused by client policy, or failure to speak HTTP (such as network connectivity problem). A

client_test.go

@@ -58,7 +58,7 @@ func TestNew_invalidURL(t *testing.T) {
 
 	expected := "parse \"://my-grafana.com\": missing protocol scheme"
 	if err.Error() != expected {
-		t.Errorf("expected error: %v; got: %s", expected, err.Error())
+		t.Errorf("expected error: %v; got: %s", expected, err)
 	}
 }
 
@@ -68,7 +68,7 @@ func TestRequest_200(t *testing.T) {
 
 	err := client.request("GET", "/foo", url.Values{}, nil, nil)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Error(err)
 	}
 }
 
@@ -78,7 +78,7 @@ func TestRequest_201(t *testing.T) {
 
 	err := client.request("GET", "/foo", url.Values{}, nil, nil)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Error(err)
 	}
 }
 
@@ -89,7 +89,7 @@ func TestRequest_400(t *testing.T) {
 	expected := `status: 400, body: {"foo":"bar"}`
 	err := client.request("GET", "/foo", url.Values{}, nil, nil)
 	if err.Error() != expected {
-		t.Errorf("expected error: %v; got: %s", expected, err.Error())
+		t.Errorf("expected error: %v; got: %s", expected, err)
 	}
 }
 
@@ -100,7 +100,23 @@ func TestRequest_500(t *testing.T) {
 	expected := `status: 500, body: {"foo":"bar"}`
 	err := client.request("GET", "/foo", url.Values{}, nil, nil)
 	if err.Error() != expected {
-		t.Errorf("expected error: %v; got: %s", expected, err.Error())
+		t.Errorf("expected error: %v; got: %s", expected, err)
+	}
+}
+
+func TestRequest_badURL(t *testing.T) {
+	server, client := gapiTestTools(t, 200, `{"foo":"bar"}`)
+	baseURL, err := url.Parse("bad-url")
+	if err != nil {
+		t.Fatal(err)
+	}
+	client.baseURL = *baseURL
+	defer server.Close()
+
+	expected := `Get "bad-url/foo": unsupported protocol scheme ""`
+	err = client.request("GET", "/foo", url.Values{}, nil, nil)
+	if err.Error() != expected {
+		t.Errorf("expected error: %v; got: %s", expected, err)
 	}
 }
 
@@ -113,7 +129,7 @@ func TestRequest_200Unmarshal(t *testing.T) {
 	}{}
 	err := client.request("GET", "/foo", url.Values{}, nil, &result)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	if result.Foo != "bar" {
@@ -130,7 +146,7 @@ func TestRequest_200UnmarshalPut(t *testing.T) {
 	}
 	data, err := json.Marshal(u)
 	if err != nil {
-		t.Fatal(err.Error())
+		t.Fatal(err)
 	}
 
 	result := struct {
@@ -140,7 +156,7 @@ func TestRequest_200UnmarshalPut(t *testing.T) {
 	q.Add("a", "b")
 	err = client.request("PUT", "/foo", q, bytes.NewBuffer(data), &result)
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Error(err)
 	}
 
 	if result.Name != "mike" {

dashboard.go

@@ -28,6 +28,9 @@ type Dashboard struct {
 	Model     map[string]interface{} `json:"dashboard"`
 	Folder    int64                  `json:"folderId"`
 	Overwrite bool                   `json:"overwrite"`
+
+	// This is only used when creating a new dashboard, it will always be empty when getting a dashboard.
+	Message string `json:"message"`
 }
 
 // SaveDashboard is a deprecated method for saving a Grafana dashboard. Use NewDashboard.

datasource.go

@@ -4,11 +4,16 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"regexp"
+	"strconv"
 )
 
+var headerNameRegex = regexp.MustCompile(`^httpHeaderName(\d+)$`)
+
 // DataSource represents a Grafana data source.
 type DataSource struct {
 	ID     int64  `json:"id,omitempty"`
+	UID    string `json:"uid,omitempty"`
 	Name   string `json:"name"`
 	Type   string `json:"type"`
 	URL    string `json:"url"`
@@ -27,16 +32,46 @@ type DataSource struct {
 	// Deprecated: Use secureJsonData.basicAuthPassword instead.
 	BasicAuthPassword string `json:"basicAuthPassword,omitempty"`
 
+	// Helper to read/write http headers
+	HTTPHeaders map[string]string `json:"-"`
+
 	JSONData       JSONData       `json:"jsonData,omitempty"`
 	SecureJSONData SecureJSONData `json:"secureJsonData,omitempty"`
 }
 
+// Required to avoid recursion during (un)marshal
+type _DataSource DataSource
+
+// Marshal DataSource
+func (ds *DataSource) MarshalJSON() ([]byte, error) {
+	dataSource := _DataSource(*ds)
+	for name, value := range ds.HTTPHeaders {
+		dataSource.JSONData.httpHeaderNames = append(dataSource.JSONData.httpHeaderNames, name)
+		dataSource.SecureJSONData.httpHeaderValues = append(dataSource.SecureJSONData.httpHeaderValues, value)
+	}
+	return json.Marshal(dataSource)
+}
+
+// Unmarshal DataSource
+func (ds *DataSource) UnmarshalJSON(b []byte) (err error) {
+	dataSource := _DataSource(*ds)
+	if err = json.Unmarshal(b, &dataSource); err == nil {
+		*ds = DataSource(dataSource)
+	}
+	ds.HTTPHeaders = make(map[string]string)
+	for _, value := range ds.JSONData.httpHeaderNames {
+		ds.HTTPHeaders[value] = "true" // HTTP Headers are not returned by the API
+	}
+	return err
+}
+
 // JSONData is a representation of the datasource `jsonData` property
 type JSONData struct {
 	// Used by all datasources
 	TLSAuth           bool `json:"tlsAuth,omitempty"`
 	TLSAuthWithCACert bool `json:"tlsAuthWithCACert,omitempty"`
 	TLSSkipVerify     bool `json:"tlsSkipVerify,omitempty"`
+	httpHeaderNames   []string
 
 	// Used by Graphite
 	GraphiteVersion string `json:"graphiteVersion,omitempty"`
@@ -94,6 +129,64 @@ type JSONData struct {
 	SigV4ExternalID    string `json:"sigV4ExternalID,omitempty"`
 	SigV4Profile       string `json:"sigV4Profile,omitempty"`
 	SigV4Region        string `json:"sigV4Region,omitempty"`
+
+	// Used by Prometheus and Loki
+	ManageAlerts    bool   `json:"manageAlerts,omitempty"`
+	AlertmanagerUID string `json:"alertmanagerUid,omitempty"`
+
+	// Used by Alertmanager
+	Implementation string `json:"implementation,omitempty"`
+}
+
+// Required to avoid recursion during (un)marshal
+type _JSONData JSONData
+
+// Marshal JSONData
+func (jd JSONData) MarshalJSON() ([]byte, error) {
+	jsonData := _JSONData(jd)
+	b, err := json.Marshal(jsonData)
+	if err != nil {
+		return nil, err
+	}
+	fields := make(map[string]interface{})
+	if err = json.Unmarshal(b, &fields); err != nil {
+		return nil, err
+	}
+	for index, name := range jd.httpHeaderNames {
+		fields[fmt.Sprintf("httpHeaderName%d", index+1)] = name
+	}
+	return json.Marshal(fields)
+}
+
+// Unmarshal JSONData
+func (jd *JSONData) UnmarshalJSON(b []byte) (err error) {
+	jsonData := _JSONData(*jd)
+	if err = json.Unmarshal(b, &jsonData); err == nil {
+		*jd = JSONData(jsonData)
+	}
+	fields := make(map[string]interface{})
+	if err = json.Unmarshal(b, &fields); err == nil {
+		headerCount := 0
+		for name := range fields {
+			match := headerNameRegex.FindStringSubmatch(name)
+			if len(match) > 0 {
+				headerCount++
+			}
+		}
+
+		jd.httpHeaderNames = make([]string, headerCount)
+		for name, value := range fields {
+			match := headerNameRegex.FindStringSubmatch(name)
+			if len(match) == 2 {
+				index, err := strconv.ParseInt(match[1], 10, 64)
+				if err != nil {
+					return err
+				}
+				jd.httpHeaderNames[index-1] = value.(string)
+			}
+		}
+	}
+	return err
 }
 
 // SecureJSONData is a representation of the datasource `secureJsonData` property
@@ -104,6 +197,7 @@ type SecureJSONData struct {
 	TLSClientKey      string `json:"tlsClientKey,omitempty"`
 	Password          string `json:"password,omitempty"`
 	BasicAuthPassword string `json:"basicAuthPassword,omitempty"`
+	httpHeaderValues  []string
 
 	// Used by Cloudwatch
 	AccessKey string `json:"accessKey,omitempty"`
@@ -117,6 +211,26 @@ type SecureJSONData struct {
 	SigV4SecretKey string `json:"sigV4SecretKey,omitempty"`
 }
 
+// Required to avoid recursion during unmarshal
+type _SecureJSONData SecureJSONData
+
+// Marshal SecureJSONData
+func (sjd SecureJSONData) MarshalJSON() ([]byte, error) {
+	secureJSONData := _SecureJSONData(sjd)
+	b, err := json.Marshal(secureJSONData)
+	if err != nil {
+		return nil, err
+	}
+	fields := make(map[string]interface{})
+	if err = json.Unmarshal(b, &fields); err != nil {
+		return nil, err
+	}
+	for index, value := range sjd.httpHeaderValues {
+		fields[fmt.Sprintf("httpHeaderValue%d", index+1)] = value
+	}
+	return json.Marshal(fields)
+}
+
 // NewDataSource creates a new Grafana data source.
 func (c *Client) NewDataSource(s *DataSource) (int64, error) {
 	data, err := json.Marshal(s)

datasource_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 const (
-	createdDataSourceJSON = `{"id":1,"message":"Datasource added", "name": "test_datasource"}`
+	createdDataSourceJSON = `{"id":1,"uid":"myuid0001","message":"Datasource added", "name": "test_datasource"}`
 )
 
 func TestNewDataSource(t *testing.T) {