Add mongo atlas support (#13)

haohanyang · web-flow · commit 1abb88a9df9b · 2024-10-13T11:36:54.000+02:00
* Add mongo+srv scheme

* bug fix

* fix lint
diff --git a/pkg/models/settings.go b/pkg/models/settings.go
@@ -8,12 +8,14 @@ import (
 )
 
 type PluginSettings struct {
-	Host       string                `json:"host"`
-	Port       int                   `json:"port"`
-	Database   string                `json:"database"`
-	AuthMethod string                `json:"authType"`
-	Username   string                `json:"username"`
-	Secrets    *SecretPluginSettings `json:"-"`
+	Host                   string                `json:"host"`
+	Port                   int                   `json:"port"`
+	Database               string                `json:"database"`
+	AuthMethod             string                `json:"authType"`
+	Username               string                `json:"username"`
+	ConnectionStringScheme string                `json:"connectionStringScheme"`
+	ConnectionParameters   string                `json:"connectionParameters"`
+	Secrets                *SecretPluginSettings `json:"-"`
 }
 
 type SecretPluginSettings struct {
diff --git a/pkg/plugin/datasource.go b/pkg/plugin/datasource.go
@@ -3,7 +3,6 @@ package plugin
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -30,27 +29,15 @@ var (
 // NewDatasource creates a new MongoDB datasource instance.
 func NewDatasource(ctx context.Context, source backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) {
 
-	var uri string
-
 	config, err := models.LoadPluginSettings(source)
 	if err != nil {
 		backend.Logger.Error(fmt.Sprintf("Failed to load plugin settings: %s", err.Error()))
 		return nil, err
 	}
 
-	if config.Database == "" {
-		return nil, errors.New("missing MongoDB database")
-	}
-
-	if config.AuthMethod == "auth-none" {
-		uri = fmt.Sprintf("mongodb://%s:%d", config.Host, config.Port)
-	} else if config.AuthMethod == "auth-username-password" {
-		if config.Username == "" || config.Secrets.Password == "" {
-			return nil, errors.New("missing MongoDB username or password")
-		}
-		uri = fmt.Sprintf("mongodb://%s:%s@%s:%d", config.Username, config.Secrets.Password, config.Host, config.Port)
-	} else {
-		return nil, errors.New("authentication method not supported")
+	uri, err := MongoUri(config)
+	if err != nil {
+		return nil, err
 	}
 
 	opts := options.Client().ApplyURI(uri)
@@ -64,8 +51,7 @@ func NewDatasource(ctx context.Context, source backend.DataSourceInstanceSetting
 	return &Datasource{
 		client:   client,
 		database: config.Database,
-		host:     config.Host,
-		port:     config.Port}, nil
+	}, nil
 }
 
 // Dispose here tells plugin SDK that plugin wants to clean up resources when a new instance
@@ -83,7 +69,7 @@ func (d *Datasource) QueryData(ctx context.Context, req *backend.QueryDataReques
 	// create response struct
 	response := backend.NewQueryDataResponse()
 	// loop over queries and execute them individually.
-	backend.Logger.Debug("New queries", d.host, d.port, d.database)
+
 	for _, q := range req.Queries {
 
 		res := d.query(ctx, req.PluginContext, q)
@@ -157,49 +143,18 @@ func (d *Datasource) query(ctx context.Context, _ backend.PluginContext, query b
 func (d *Datasource) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
 	res := &backend.CheckHealthResult{}
 	backend.Logger.Debug("Checking health")
-	config, err := models.LoadPluginSettings(*req.PluginContext.DataSourceInstanceSettings)
 
+	config, err := models.LoadPluginSettings(*req.PluginContext.DataSourceInstanceSettings)
 	if err != nil {
 		res.Status = backend.HealthStatusError
 		res.Message = "Unable to load settings"
 		return res, nil
 	}
 
-	backend.Logger.Debug(fmt.Sprintf("Config: %v", config))
-
-	if config.AuthMethod == "" {
-		res.Status = backend.HealthStatusError
-		res.Message = "Please specify the authentication type"
-		return res, nil
-	}
-
-	if config.Host == "" {
-		res.Status = backend.HealthStatusError
-		res.Message = "Please specify the host address"
-		return res, nil
-	}
-
-	if config.Database == "" {
-		res.Status = backend.HealthStatusError
-		res.Message = "Please specify the database"
-		return res, nil
-	}
-
-	var uri string
-
-	if config.AuthMethod == "auth-none" {
-		uri = fmt.Sprintf("mongodb://%s:%d", config.Host, config.Port)
-	} else if config.AuthMethod == "auth-username-password" {
-		if config.Username == "" || config.Secrets.Password == "" {
-			res.Status = backend.HealthStatusError
-			res.Message = "Please specify the username and password"
-			return res, nil
-		}
-		uri = fmt.Sprintf("mongodb://%s:%s@%s:%d", config.Username, config.Secrets.Password, config.Host, config.Port)
-	} else {
+	uri, err := MongoUri(config)
+	if err != nil {
 		res.Status = backend.HealthStatusError
-		res.Message = "Please specify the authentication type"
-		return res, nil
+		res.Message = err.Error()
 	}
 
 	opts := options.Client().ApplyURI(uri).SetTimeout(5 * time.Second)
diff --git a/pkg/plugin/datasource_test.go b/pkg/plugin/datasource_test.go
@@ -49,8 +49,6 @@ func TestQueryTableData(t *testing.T) {
 
 	ds := Datasource{
 		client:   client,
-		host:     "localhost",
-		port:     27018,
 		database: "test",
 	}
 
diff --git a/pkg/plugin/types.go b/pkg/plugin/types.go
@@ -9,8 +9,6 @@ import (
 // Datasource is a mongo datasource which can respond to data queries, reports
 // its health and has streaming skills.
 type Datasource struct {
-	host     string
-	port     int
 	database string
 	client   *mongo.Client
 }
diff --git a/pkg/plugin/utils.go b/pkg/plugin/utils.go
@@ -2,9 +2,11 @@ package plugin
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 
 	"github.com/grafana/grafana-plugin-sdk-go/data"
+	"github.com/haohanyang/mongodb-datasource/pkg/models"
 )
 
 func PrintDataFrame(dataFrame *data.Frame) {
@@ -61,3 +63,35 @@ func null[K any]() *K {
 	var nullValue *K
 	return nullValue
 }
+
+// Validate mongo connection configuration and return connection string
+func MongoUri(config *models.PluginSettings) (string, error) {
+	var uri string
+	var creds string
+	var params string
+
+	if config.Database == "" {
+		return uri, errors.New("missing MongoDB database")
+	}
+
+	if config.AuthMethod == "auth-username-password" {
+		if config.Username == "" || config.Secrets.Password == "" {
+			return uri, errors.New("missing MongoDB username or password")
+		}
+		creds = fmt.Sprintf("%s:%s@", config.Username, config.Secrets.Password)
+	} else if config.AuthMethod != "auth-none" {
+		return uri, errors.New("unsupported auth method")
+	}
+
+	if config.ConnectionParameters != "" {
+		params = "?" + config.ConnectionParameters
+	}
+
+	if config.ConnectionStringScheme == "dns_seed_list" {
+		uri = fmt.Sprintf("mongodb+srv://%s%s/%s", creds, config.Host, params)
+	} else {
+		uri = fmt.Sprintf("mongodb://%s%s:%d/%s", creds, config.Host, config.Port, params)
+	}
+
+	return uri, nil
+}
diff --git a/src/components/ConfigEditor.tsx b/src/components/ConfigEditor.tsx
@@ -1,7 +1,8 @@
 import React, { ChangeEvent } from "react";
 import { Divider, Field, FieldSet, InlineField, InlineFieldRow, Input, RadioButtonGroup, SecretInput } from "@grafana/ui";
 import { DataSourcePluginOptionsEditorProps, SelectableValue } from "@grafana/data";
-import { MongoDataSourceOptions, MySecureJsonData, MongoDBAuthMethod } from "../types";
+import { MongoDataSourceOptions, MySecureJsonData, MongoDBAuthMethod, ConnectionStringScheme } from "../types";
+;
 
 interface Props extends DataSourcePluginOptionsEditorProps<MongoDataSourceOptions, MySecureJsonData> { }
 
@@ -10,6 +11,11 @@ const mongoDBAuthMethods: SelectableValue[] = [
   { label: "Username/Password", value: MongoDBAuthMethod.USERNAME_PASSWORD }
 ];
 
+const mongoConnectionStringSchemes: SelectableValue[] = [
+  { label: "mongodb", value: ConnectionStringScheme.STANDARD, description: "Standard Connection String Format" },
+  { label: "mongodb+srv", value: ConnectionStringScheme.DNS_SEED_LIST, description: "DNS Seed List Connection Format" }
+];
+
 export function ConfigEditor(props: Props) {
   const { onOptionsChange, options } = props;
   const { jsonData, secureJsonFields, secureJsonData } = options;
@@ -22,6 +28,10 @@ export function ConfigEditor(props: Props) {
     jsonData.port = 27017;
   }
 
+  if (!jsonData.connectionStringScheme) {
+    jsonData.connectionStringScheme = ConnectionStringScheme.STANDARD;
+  }
+
 
   const onHostChange = (event: ChangeEvent<HTMLInputElement>) => {
     onOptionsChange({
@@ -43,6 +53,15 @@ export function ConfigEditor(props: Props) {
     });
   };
 
+  const onConnectionParametersChange = (event: ChangeEvent<HTMLInputElement>) => {
+    onOptionsChange({
+      ...options,
+      jsonData: {
+        ...jsonData,
+        connectionParameters: event.target.value,
+      },
+    });
+  };
 
   const onPortChange = (event: ChangeEvent<HTMLInputElement>) => {
     onOptionsChange({
@@ -75,6 +94,16 @@ export function ConfigEditor(props: Props) {
     });
   };
 
+  const onConnectionStringSchemeChange = (scheme: string) => {
+    onOptionsChange({
+      ...options,
+      jsonData: {
+        ...jsonData,
+        connectionStringScheme: scheme,
+      },
+    });
+  };
+
   const onPasswordChange = (event: ChangeEvent<HTMLInputElement>) => {
     onOptionsChange({
       ...options,
@@ -100,6 +129,13 @@ export function ConfigEditor(props: Props) {
 
   return (
     <>
+      <Field label="Connection string scheme">
+        <RadioButtonGroup
+          options={mongoConnectionStringSchemes}
+          value={jsonData.connectionStringScheme || ConnectionStringScheme.STANDARD}
+          onChange={onConnectionStringSchemeChange}
+        />
+      </Field>
       <InlineFieldRow label="Connection">
         <InlineField label="Host" tooltip="MongoDB host address">
           <Input
@@ -110,17 +146,16 @@ export function ConfigEditor(props: Props) {
             width={30}
           ></Input>
         </InlineField>
-        <InlineField label="Port" tooltip="MongoDB port">
+        {jsonData.connectionStringScheme === ConnectionStringScheme.STANDARD && <InlineField label="Port" tooltip="MongoDB port">
           <Input
-            required
             id="config-editor-port"
             value={jsonData.port}
             type="number"
             onChange={onPortChange}
             width={15}
             defaultValue={27017}
           ></Input>
-        </InlineField>
+        </InlineField>}
       </InlineFieldRow>
       <InlineFieldRow>
         <InlineField label="Database" tooltip="MongoDB database">
@@ -133,6 +168,15 @@ export function ConfigEditor(props: Props) {
           ></Input>
         </InlineField>
       </InlineFieldRow>
+      <InlineField label="Connection parameters" tooltip="Connection parameters appended to the connection string. For example retryWrites=true&w=majority&appName=default-cluster">
+        <Input
+          required
+          id="config-editor-connection-parameters"
+          value={jsonData.connectionParameters}
+          onChange={onConnectionParametersChange}
+          width={35}
+        ></Input>
+      </InlineField>
       <Divider />
       <FieldSet label="Authentication">
         <Field label="Authentication method">
diff --git a/src/types.ts b/src/types.ts
@@ -46,15 +46,22 @@ export const MongoDBAuthMethod = {
   USERNAME_PASSWORD: "auth-username-password"
 };
 
+export const ConnectionStringScheme = {
+  STANDARD: "standard",
+  DNS_SEED_LIST: "dns_seed_list"
+};
+
 
 /**
  * These are options configured for each DataSource instance
  */
 export interface MongoDataSourceOptions extends DataSourceJsonData {
+  connectionStringScheme?: string;
   host?: string;
   port?: number;
   database?: string;
   username?: string;
+  connectionParameters?: string;
 }
 
 /**

Original file line number	Diff line number	Diff line change
`@@ -49,8 +49,6 @@ func TestQueryTableData(t *testing.T) {`
`49`	`49`
`50`	`50`	`ds := Datasource{`
`51`	`51`	`client: client,`
`52`		`- host: "localhost",`
`53`		`- port: 27018,`
`54`	`52`	`database: "test",`
`55`	`53`	`}`
`56`	`54`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,6 @@ import (`
`9`	`9`	`// Datasource is a mongo datasource which can respond to data queries, reports`
`10`	`10`	`// its health and has streaming skills.`
`11`	`11`	`type Datasource struct {`
`12`		`- host string`
`13`		`- port int`
`14`	`12`	`database string`
`15`	`13`	`client *mongo.Client`
`16`	`14`	`}`