New auto group

Currently automatically groups as namespaces when available
More logic can easily be inserted

Author: jotak

web/src/components/netflow-traffic.tsx

@@ -58,6 +58,7 @@ import { FiltersToolbar } from './toolbar/filters-toolbar';
 import ChipsPopover from './toolbar/filters/chips-popover';
 import HistogramToolbar from './toolbar/histogram-toolbar';
 import ViewOptionsToolbar from './toolbar/view-options-toolbar';
+import { resolveGroupTypes } from '../model/scope';
 
 export type ViewId = 'overview' | 'table' | 'topology';
 
@@ -289,7 +290,9 @@ export const NetflowTraffic: React.FC<NetflowTrafficProps> = ({
       query.aggregateBy = model.metricScope;
       if (model.selectedViewId === 'topology') {
         query.type = model.topologyMetricType;
-        query.groups = model.topologyOptions.groupTypes !== 'none' ? model.topologyOptions.groupTypes : undefined;
+        const scopes = getAvailableScopes();
+        const resolvedGroup = resolveGroupTypes(model.topologyOptions.groupTypes, model.metricScope, scopes);
+        query.groups = resolvedGroup !== 'none' ? resolvedGroup : undefined;
       } else if (model.selectedViewId === 'overview') {
         query.limit = topValues.includes(model.limit) ? model.limit : topValues[0];
         query.groups = undefined;

web/src/components/tabs/netflow-topology/2d/topology-content.tsx

@@ -207,7 +207,7 @@ export const TopologyContent: React.FC<TopologyContentProps> = ({
 
   const onStepInto = React.useCallback(
     (data: Decorated<ElementData>) => {
-      const groupTypes: TopologyGroupTypes = metricScope;
+      const groupTypes: TopologyGroupTypes = options.groupTypes === 'auto' ? 'auto' : metricScope;
       const scope = getStepInto(
         metricScope,
         scopes.map(sc => sc.id)

web/src/model/netflow-traffic.ts

@@ -150,7 +150,7 @@ export function netflowTrafficModel() {
       // Invalidate groups if necessary, when metrics scope changed
       const groups = getGroupsForScope(scope, config.scopes);
       if (!groups.includes(topologyOptions.groupTypes)) {
-        setTopologyOptions({ ...topologyOptions, groupTypes: 'none' });
+        setTopologyOptions({ ...topologyOptions, groupTypes: 'auto' });
       }
     },
     [setMetricScope, config.scopes, topologyOptions, setTopologyOptions]

web/src/model/scope.ts

@@ -22,18 +22,32 @@ export const getScopeName = (sc: ScopeConfigDef | undefined, t: (k: string) => s
   return sc.name || sc.id;
 };
 
-export const getGroupsForScope = (scopeId: FlowScope, scopes: ScopeConfigDef[]) => {
+export const getGroupsForScope = (scopeId: FlowScope, scopes: ScopeConfigDef[]): TopologyGroupTypes[] => {
   const scope = scopes.find(sc => sc.id === scopeId);
   if (scope?.groups?.length) {
     const availableParts = scopes.map(sc => `${sc.id}s`);
-    return ['none', ...scope.groups.filter(gp => gp.split('+').every(part => availableParts.includes(part)))];
+    return ['none', 'auto', ...scope.groups.filter(gp => gp.split('+').every(part => availableParts.includes(part)))];
   }
-  return ['none'];
+  return ['none', 'auto'];
+};
+
+export const resolveGroupTypes = (inGroupTypes: TopologyGroupTypes, scopeId: FlowScope, scopes: ScopeConfigDef[]): TopologyGroupTypes => {
+  if (inGroupTypes === 'auto') {
+    const groups = getGroupsForScope(scopeId, scopes);
+    if (groups.includes('namespaces')) {
+      return 'namespaces';
+    }
+    // More logic can be added here for more default behaviours
+    return 'none';
+  }
+  return inGroupTypes;
 };
 
 export const getGroupName = (group: TopologyGroupTypes, scopes: ScopeConfigDef[], t: (k: string) => string) => {
   if (group === 'none') {
     return t('None');
+  } else if (group === 'auto') {
+    return t('Auto');
   } else if (group.includes('+')) {
     return group
       .split('+')

web/src/model/topology.ts

@@ -25,7 +25,7 @@ import { createPeer, getFormattedValue } from '../utils/metrics';
 import { defaultMetricFunction, defaultMetricType } from '../utils/router';
 import { FlowScope, Groups, MetricFunction, MetricType, NodeType, StatFunction } from './flow-query';
 import { getStat } from './metrics';
-import { getStepInto, isDirectionnal, ScopeConfigDef } from './scope';
+import { getStepInto, isDirectionnal, resolveGroupTypes, ScopeConfigDef } from './scope';
 
 export enum LayoutName {
   threeD = '3d',
@@ -40,7 +40,7 @@ export enum LayoutName {
   grid = 'Grid'
 }
 
-export type TopologyGroupTypes = 'none' | Groups;
+export type TopologyGroupTypes = 'none' | 'auto' | Groups;
 
 export interface TopologyOptions {
   maxEdgeStat: number;
@@ -66,7 +66,7 @@ export const DefaultOptions: TopologyOptions = {
   startCollapsed: false,
   truncateLength: TruncateLength.M,
   layout: LayoutName.colaNoForce,
-  groupTypes: 'none',
+  groupTypes: 'auto',
   lowScale: 0.3,
   medScale: 0.5,
   metricFunction: defaultMetricFunction,
@@ -537,11 +537,12 @@ export const generateDataModel = (
   const addPossibleGroups = (peer: TopologyMetricPeer): NodeModel | undefined => {
     // groups are all possible scopes except last one
     const parentScopes = ContextSingleton.getScopes().slice(0, -1);
+    const resolvedGroups = resolveGroupTypes(options.groupTypes, metricScope, scopes);
 
     // build parent tree from biggest to smallest group
     let parent: NodeModel | undefined = undefined;
     parentScopes.forEach(sc => {
-      if (options.groupTypes.includes(`${sc.id}s`) && !_.isEmpty(peer[sc.id])) {
+      if (resolvedGroups.includes(`${sc.id}s`) && !_.isEmpty(peer[sc.id])) {
         parent = addGroup(
           { [sc.id]: peer[sc.id], namespace: ['namespace', 'owner'].includes(sc.id) ? peer.namespace : undefined },
           sc.id,