Load data in rules tables

web/packages/teleport/src/Integrations/status/AwsOidc/Details/Details.tsx

@@ -26,8 +26,7 @@ import { useAwsOidcStatus } from 'teleport/Integrations/status/AwsOidc/useAwsOid
 import { AwsResource } from 'teleport/Integrations/status/AwsOidc/StatCard';
 import { IntegrationKind } from 'teleport/services/integrations';
 import { Rds } from 'teleport/Integrations/status/AwsOidc/Details/Rds';
-import { Ec2 } from 'teleport/Integrations/status/AwsOidc/Details/Ec2';
-import { Eks } from 'teleport/Integrations/status/AwsOidc/Details/Eks';
+import { Rules } from 'teleport/Integrations/status/AwsOidc/Details/Rules';
 
 export function Details() {
   const { resourceKind } = useParams<{
@@ -43,8 +42,8 @@ export function Details() {
       {integration && (
         <AwsOidcHeader integration={integration} resource={resourceKind} />
       )}
-      {resourceKind == AwsResource.ec2 && <Ec2 />}
-      {resourceKind == AwsResource.eks && <Eks />}
+      {resourceKind == AwsResource.ec2 && <Rules />}
+      {resourceKind == AwsResource.eks && <Rules />}
       {resourceKind == AwsResource.rds && <Rds />}
     </FeatureBox>
   );

web/packages/teleport/src/Integrations/status/AwsOidc/Details/Rules.tsx

@@ -16,32 +16,65 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import React from 'react';
+import React, { useEffect } from 'react';
 
 import Table, { LabelCell } from 'design/DataTable';
 
+import { useParams } from 'react-router';
+
+import { useAsync } from 'shared/hooks/useAsync';
+import { Indicator } from 'design';
+import { Danger } from 'design/Alert';
+
+import {
+  IntegrationKind,
+  integrationService,
+} from 'teleport/services/integrations';
+import { AwsResource } from 'teleport/Integrations/status/AwsOidc/StatCard';
+
 export function Rules() {
+  const { name, resourceKind } = useParams<{
+    type: IntegrationKind;
+    name: string;
+    resourceKind: AwsResource;
+  }>();
+
+  const [attempt, fetchRules] = useAsync(() =>
+    integrationService.fetchIntegrationRules(name, resourceKind)
+  );
+
+  useEffect(() => {
+    fetchRules();
+  }, []);
+
+  if (attempt.status == 'processing') {
+    return <Indicator />;
+  }
+
+  if (attempt.status == 'error') {
+    return <Danger>{attempt.statusText}</Danger>;
+  }
+
+  if (!attempt.data) {
+    return null;
+  }
+
   return (
     <Table
-      data={[]}
+      data={attempt.data.rules}
       columns={[
-        {
-          key: 'name',
-          headerText: 'Integration Name',
-          isSortable: true,
-        },
         {
           key: 'region',
           headerText: 'Region',
           isSortable: true,
         },
         {
-          key: 'tags',
-          headerText: 'Tags',
+          key: 'labelMatcher',
+          headerText: getResourceTerm(resourceKind),
           isSortable: true,
           onSort: (a, b) => {
-            const aStr = a.tags.toString();
-            const bStr = b.tags.toString();
+            const aStr = a.labelMatcher.toString();
+            const bStr = b.labelMatcher.toString();
 
             if (aStr < bStr) {
               return -1;
@@ -52,11 +85,22 @@ export function Rules() {
 
             return 0;
           },
-          render: ({ tags }) => <LabelCell data={tags} />,
+          render: ({ labelMatcher }) => (
+            <LabelCell data={labelMatcher.map(l => `${l.value}:${l.name}`)} />
+          ),
         },
       ]}
-      emptyText="Rules details coming soon"
+      emptyText={`No ${resourceKind} data`}
       isSearchable
     />
   );
 }
+
+function getResourceTerm(resource: AwsResource): string {
+  switch (resource) {
+    case AwsResource.rds:
+      return 'Tags';
+    default:
+      return 'Labels';
+  }
+}

web/packages/teleport/src/config.ts

@@ -327,6 +327,9 @@ const cfg = {
     integrationsPath: '/v1/webapi/sites/:clusterId/integrations/:name?',
     integrationStatsPath:
       '/v1/webapi/sites/:clusterId/integrations/:name/stats',
+    integrationRulesPath:
+      '/v1/webapi/sites/:clusterId/integrations/:name/discoveryrules?resourceType=:resourceType',
+
     thumbprintPath: '/v1/webapi/thumbprint',
     pingAwsOidcIntegrationPath:
       '/v1/webapi/sites/:clusterId/integrations/aws-oidc/:name/ping',
@@ -994,6 +997,15 @@ const cfg = {
     });
   },
 
+  getIntegrationRulesUrl(name: string, resourceType: AwsResource) {
+    const clusterId = cfg.proxyCluster;
+    return generatePath(cfg.api.integrationRulesPath, {
+      clusterId,
+      name,
+      resourceType,
+    });
+  },
+
   getPingAwsOidcIntegrationUrl({
     integrationName,
     clusterId,

web/packages/teleport/src/services/integrations/integrations.ts

@@ -19,6 +19,8 @@
 import api from 'teleport/services/api';
 import cfg from 'teleport/config';
 
+import { AwsResource } from 'teleport/Integrations/status/AwsOidc/StatCard';
+
 import makeNode from '../nodes/makeNode';
 import auth from '../auth/auth';
 import { App } from '../apps';
@@ -60,6 +62,7 @@ import {
   AwsOidcPingResponse,
   AwsOidcPingRequest,
   IntegrationWithSummary,
+  IntegrationDiscoveryRules,
 } from './types';
 
 export const integrationService = {
@@ -420,6 +423,17 @@ export const integrationService = {
       return resp;
     });
   },
+
+  fetchIntegrationRules(
+    name: string,
+    resourceType: AwsResource
+  ): Promise<IntegrationDiscoveryRules> {
+    return api
+      .get(cfg.getIntegrationRulesUrl(name, resourceType))
+      .then(resp => {
+        return resp;
+      });
+  },
 };
 
 export function makeIntegrations(json: any): Integration[] {

web/packages/teleport/src/services/integrations/types.ts

@@ -298,6 +298,31 @@ export type IntegrationWithSummary = {
   awseks: ResourceTypeSummary;
 };
 
+// IntegrationDiscoveryRules contains the list of discovery rules for a given Integration.
+export type IntegrationDiscoveryRules = {
+  // rules is the list of integration rules.
+  rules: IntegrationDiscoveryRule[];
+  // nextKey is the position to resume listing rules.
+  nextKey: string;
+};
+
+// IntegrationDiscoveryRule describes a discovery rule associated with an integration.
+export type IntegrationDiscoveryRule = {
+  // resourceType indicates the type of resource that this rule targets.
+  // This is the same value that is set in DiscoveryConfig.AWS.<Matcher>.Types
+  // Example: ec2, rds, eks
+  resourceType: string;
+  // region where this rule applies to.
+  region: string;
+  // labelMatcher is the set of labels that are used to filter the resources before trying to auto-enroll them.
+  labelMatcher: Label[];
+  // discoveryConfig is the name of the DiscoveryConfig that created this rule.
+  discoveryConfig: string;
+  // lastSync contains the time when this rule was used.
+  // If empty, it indicates that the rule is not being used.
+  lastSync: number;
+};
+
 // ResourceTypeSummary contains the summary of the enrollment rules and found resources by the integration.
 export type ResourceTypeSummary = {
   // rulesCount is the number of enrollment rules that are using this integration.