feat: implement metricFindQuery

src/datasources/system/SystemDataSource.ts

@@ -7,11 +7,12 @@ import {
   FieldType,
   CoreApp,
   toDataFrame,
+  MetricFindValue,
 } from '@grafana/data';
 
-import { TestingStatus, getBackendSrv } from '@grafana/runtime';
+import { TestingStatus, getBackendSrv, getTemplateSrv } from '@grafana/runtime';
 
-import { QueryType, SystemMetadata, SystemQuery, SystemSummary } from './types';
+import { QueryType, SystemMetadata, SystemQuery, SystemSummary, VariableQuery } from './types';
 import { defaultProjection } from './constants';
 import { NetworkUtils } from './network-utils';
 
@@ -22,7 +23,7 @@ export class SystemDataSource extends DataSourceApi<SystemQuery> {
     this.baseUrl = this.instanceSettings.url + '/nisysmgmt/v1';
   }
 
-  transformProjection(projections: string[]): string { 
+  transformProjection(projections: string[]): string {
     let result = "new(";
 
     projections.forEach(function (field) {
@@ -40,6 +41,13 @@ export class SystemDataSource extends DataSourceApi<SystemQuery> {
     return NetworkUtils.getIpAddressFromInterfaces(ip4Interface) || NetworkUtils.getIpAddressFromInterfaces(ip6Interface);
   }
 
+  async metricFindQuery(query: VariableQuery, options?: any): Promise<MetricFindValue[]> {
+    const response = await getBackendSrv().post<{ data: VariableQuery[] }>(this.baseUrl + '/query-systems', { projection: "new(id, alias)" });
+    const values = response.data.map(frame => ({ text: frame.alias, value: frame.id }));
+
+    return values;
+  }
+
   async query(options: DataQueryRequest<SystemQuery>): Promise<DataQueryResponse> {
     // Return a constant for each query.
     const data = await Promise.all(options.targets.map(async (target) => {
@@ -53,20 +61,25 @@ export class SystemDataSource extends DataSourceApi<SystemQuery> {
           ],
         });
       } else {
-        let metadataResponse = await getBackendSrv().post<{ data: SystemMetadata[] }>(this.baseUrl + '/query-systems', { projection: this.transformProjection(defaultProjection) });
-
+        const resolvedId = getTemplateSrv().replace(target.systemName, options.scopedVars);
+        const postBody = {
+          filter: resolvedId ? `id = "${resolvedId}" || alias = "${resolvedId}"` : '',
+          projection: this.transformProjection(defaultProjection),
+          orderBy: 'createdTimeStamp DESC'
+        };
+        let metadataResponse = await getBackendSrv().post<{ data: SystemMetadata[] }>(this.baseUrl + '/query-systems', postBody);
         return toDataFrame({
           fields: [
-            { name: 'id', values: metadataResponse.data.map(m => m.id)},
-            { name: 'alias', values: metadataResponse.data.map(m => m.alias)},
-            { name: 'connection status', values: metadataResponse.data.map(m => m.state)},
-            { name: 'locked status', values: metadataResponse.data.map(m => m.locked)},
-            { name: 'system start time', values: metadataResponse.data.map(m => m.systemStartTime)},
-            { name: 'model', values: metadataResponse.data.map(m => m.model)},
-            { name: 'vendor', values: metadataResponse.data.map(m => m.vendor)},
-            { name: 'operating system', values: metadataResponse.data.map(m => m.osFullName)},
-            { name: 'ip address', values: metadataResponse.data.map(m => this.getIpAddress(m.ip4Interfaces, m.ip6Interfaces))},
-            { name: 'workspace', values: metadataResponse.data.map(m => m.workspace)},
+            { name: 'id', values: metadataResponse.data.map(m => m.id) },
+            { name: 'alias', values: metadataResponse.data.map(m => m.alias) },
+            { name: 'connection status', values: metadataResponse.data.map(m => m.state) },
+            { name: 'locked status', values: metadataResponse.data.map(m => m.locked) },
+            { name: 'system start time', values: metadataResponse.data.map(m => m.systemStartTime) },
+            { name: 'model', values: metadataResponse.data.map(m => m.model) },
+            { name: 'vendor', values: metadataResponse.data.map(m => m.vendor) },
+            { name: 'operating system', values: metadataResponse.data.map(m => m.osFullName) },
+            { name: 'ip address', values: metadataResponse.data.map(m => this.getIpAddress(m.ip4Interfaces, m.ip6Interfaces)) },
+            { name: 'workspace', values: metadataResponse.data.map(m => m.workspace) },
           ]
         });
       }

src/datasources/system/components/SystemQueryEditor.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { InlineField, InlineFieldRow, RadioButtonGroup } from '@grafana/ui';
+import { InlineField, InlineFieldRow, Input, RadioButtonGroup } from '@grafana/ui';
 import { QueryEditorProps } from '@grafana/data';
 import { SystemDataSource } from '../SystemDataSource';
 import { QueryType, SystemQuery } from '../types';
@@ -13,13 +13,26 @@ export function SystemQueryEditor({ query, onChange, onRunQuery }: Props) {
     onRunQuery();
   }
 
+  const onIdBlur = (e: React.FocusEvent<HTMLInputElement>) => {
+    const id = e.currentTarget.value;
+    if (query.systemName !== id) {
+      onChange({ ...query, systemName: id })
+      onRunQuery(); 
+    }
+  }
+
   return (
     <div>
       <InlineFieldRow >
         <InlineField label="Query type">
           <RadioButtonGroup options={enumToOptions(QueryType)} onChange={onQueryTypeChange} value={query.queryKind} />
         </InlineField>
       </InlineFieldRow>
+      <InlineFieldRow>
+        <InlineField label="System" tooltip="Enter system ID or alias" >
+          <Input placeholder="All systems" onBlur={onIdBlur} defaultValue={query.systemName} />
+        </InlineField>
+      </InlineFieldRow>
     </div>
   );
 }

src/datasources/system/module.ts

@@ -5,4 +5,5 @@ import { HttpConfigEditor } from 'core/components/HttpConfigEditor';
 
 export const plugin = new DataSourcePlugin(SystemDataSource)
   .setConfigEditor(HttpConfigEditor)
-  .setQueryEditor(SystemQueryEditor);
+  .setQueryEditor(SystemQueryEditor)
+  .setVariableQueryEditor(() => null);

src/datasources/system/types.ts

@@ -6,7 +6,8 @@ export enum QueryType {
 }
 
 export interface SystemQuery extends DataQuery {
-  queryKind: QueryType
+  queryKind: QueryType,
+  systemName: string
 }
 
 export interface SystemSummary {
@@ -27,3 +28,8 @@ export interface SystemMetadata {
   ip6Interfaces: Record<string, string[]>,
   workspace: string
 }
+
+export interface VariableQuery {
+  id: string,
+  alias: string
+}