@rancher/shell 0.1.0

package/config/product/cis.js

@@ -0,0 +1,157 @@
+import { DSL } from '@shell/store/type-map';
+import { CIS } from '@shell/config/types';
+import { STATE, NAME as NAME_HEADER, AGE } from '@shell/config/table-headers';
+
+export const NAME = 'cis';
+export const CHART_NAME = 'rancher-cis-benchmark';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    weightType,
+    configureType,
+    headers
+  } = DSL(store, NAME);
+
+  product({
+    ifHaveGroup: /^(.*\.)*cis\.cattle\.io$/,
+    icon:        'cis',
+  });
+
+  weightType(CIS.CLUSTER_SCAN, 3, true);
+  weightType(CIS.CLUSTER_SCAN_PROFILE, 2, true);
+  weightType(CIS.BENCHMARK, 1, true);
+
+  basicType([
+    'cis.cattle.io.clusterscan',
+    'cis.cattle.io.clusterscanprofile',
+    'cis.cattle.io.clusterscanbenchmark',
+  ]);
+
+  configureType(CIS.CLUSTER_SCAN, { canYaml: false, showAge: false });
+
+  headers(CIS.CLUSTER_SCAN, [
+    STATE,
+    NAME_HEADER,
+    {
+      name:          'clusterScanProfile',
+      label:         'Profile',
+      value:         'status.lastRunScanProfileName',
+      formatter:     'Link',
+      formatterOpts: { options: { internal: true }, to: { name: 'c-cluster-product-resource-id', params: { resource: CIS.CLUSTER_SCAN_PROFILE } } },
+      sort:          ['status.lastRunScanProfileName'],
+    },
+    {
+      name:        'total',
+      labelKey:    'cis.scan.total',
+      value:       'status.summary.total',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:        'pass',
+      value:       'status.summary.pass',
+      labelKey:    'cis.scan.pass',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:        'fail',
+      labelKey:    'cis.scan.fail',
+      value:       'status.summary.fail',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:        'warn',
+      labelKey:    'cis.scan.warn',
+      value:       'status.summary.warn',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:        'skip',
+      labelKey:    'cis.scan.skip',
+      value:       'status.summary.skip',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:        'notApplicable',
+      labelKey:    'cis.scan.notApplicable',
+      value:       'status.summary.notApplicable',
+      formatter: 'ScanResult'
+
+    },
+    {
+      name:          'nextScanAt',
+      label:         'Next Scan',
+      value:         'status.NextScanAt',
+      formatter:     'LiveDate',
+      formatterOpts: { addPrefix: false },
+      sort:          'status.nextScanAt:desc',
+      width:         150,
+      align:         'right',
+    },
+    {
+      name:          'lastRunTimestamp',
+      label:         'Last Run',
+      value:         'status.lastRunTimestamp',
+      formatter:     'LiveDate',
+      formatterOpts: { addSuffix: true },
+      sort:          'status.lastRunTimestamp:desc',
+      width:         150,
+      align:         'right',
+      defaultSort:   true,
+    },
+  ]);
+
+  headers(CIS.CLUSTER_SCAN_PROFILE, [
+    STATE,
+    NAME_HEADER,
+    {
+      name:          'benchmarkVersion',
+      labelKey:      'cis.benchmarkVersion',
+      value:         'spec.benchmarkVersion',
+      formatter:     'Link',
+      formatterOpts: { options: { internal: true }, to: { name: 'c-cluster-product-resource-id', params: { resource: CIS.BENCHMARK } } },
+    },
+    {
+      name:     'skippedTests',
+      labelKey: 'cis.testsSkipped',
+      value:    'numberTestsSkipped',
+      sort:     ['numberTestsSkipped']
+    }
+  ]);
+
+  headers(CIS.BENCHMARK, [
+    STATE,
+    NAME_HEADER,
+    {
+      name:          'clusterProvider',
+      labelKey:      'cis.clusterProvider',
+      value:         'spec.clusterProvider',
+    },
+    {
+      name:        'minKubernetesVersion',
+      labelKey:    'tableHeaders.minKubernetesVersion',
+      value:       'spec.minKubernetesVersion',
+      dashIfEmpty: true,
+
+    },
+    {
+      name:        'maxKubernetesVersion',
+      labelKey:    'tableHeaders.maxKubernetesVersion',
+      value:       'spec.maxKubernetesVersion',
+      dashIfEmpty: true,
+    },
+    {
+      name:          'isDefault',
+      labelKey:      'tableHeaders.builtIn',
+      formatter:     'Checked',
+      value:     'isDefault'
+    },
+    AGE
+  ]);
+}

package/config/product/explorer.js

@@ -0,0 +1,306 @@
+import {
+  CONFIG_MAP,
+  EVENT,
+  NODE, SECRET, INGRESS,
+  WORKLOAD, WORKLOAD_TYPES, SERVICE, HPA, NETWORK_POLICY, PV, PVC, STORAGE_CLASS, POD,
+  RBAC,
+  MANAGEMENT,
+  NAMESPACE,
+  NORMAN,
+  VIRTUAL_TYPES,
+} from '@shell/config/types';
+
+import {
+  STATE, NAME as NAME_COL, NAMESPACE as NAMESPACE_COL, AGE, KEYS,
+  INGRESS_DEFAULT_BACKEND, INGRESS_TARGET,
+  SPEC_TYPE, TARGET_PORT, SELECTOR, NODE as NODE_COL, TYPE, WORKLOAD_IMAGES, POD_IMAGES,
+  USER_ID, USERNAME, USER_DISPLAY_NAME, USER_PROVIDER, WORKLOAD_ENDPOINTS, STORAGE_CLASS_DEFAULT,
+  STORAGE_CLASS_PROVISIONER, PERSISTENT_VOLUME_SOURCE,
+  HPA_REFERENCE, MIN_REPLICA, MAX_REPLICA, CURRENT_REPLICA,
+  ACCESS_KEY, DESCRIPTION, EXPIRES, EXPIRY_STATE, SUB_TYPE, AGE_NORMAN, SCOPE_NORMAN, PERSISTENT_VOLUME_CLAIM, RECLAIM_POLICY, PV_REASON, WORKLOAD_HEALTH_SCALE, POD_RESTARTS
+} from '@shell/config/table-headers';
+
+import { DSL } from '@shell/store/type-map';
+
+export const NAME = 'explorer';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    ignoreType,
+    mapGroup,
+    weightGroup,
+    weightType,
+    headers,
+    virtualType,
+    componentForType,
+    configureType,
+    setGroupDefaultType,
+  } = DSL(store, NAME);
+
+  product({
+    removable:           false,
+    weight:              3,
+    showNamespaceFilter: true,
+    icon:                'compass',
+    typeStoreMap:        {
+      [MANAGEMENT.PROJECT]:                       'management',
+      [MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING]: 'management',
+      [MANAGEMENT.PROJECT_ROLE_TEMPLATE_BINDING]: 'management'
+    }
+  });
+
+  basicType(['cluster-dashboard', 'cluster-tools']);
+  basicType([
+    'cluster-dashboard',
+    'projects-namespaces',
+    'namespaces',
+    NODE,
+    VIRTUAL_TYPES.CLUSTER_MEMBERS,
+  ], 'cluster');
+  basicType([
+    SERVICE,
+    INGRESS,
+    HPA,
+    NETWORK_POLICY,
+  ], 'serviceDiscovery');
+  basicType([
+    PV,
+    PVC,
+    STORAGE_CLASS,
+    SECRET,
+    CONFIG_MAP
+  ], 'storage');
+  basicType([
+    WORKLOAD,
+    WORKLOAD_TYPES.DEPLOYMENT,
+    WORKLOAD_TYPES.DAEMON_SET,
+    WORKLOAD_TYPES.STATEFUL_SET,
+    WORKLOAD_TYPES.JOB,
+    WORKLOAD_TYPES.CRON_JOB,
+    POD,
+  ], 'workload');
+
+  weightGroup('cluster', 99, true);
+  weightGroup('workload', 98, true);
+  weightGroup('serviceDiscovery', 96, true);
+  weightGroup('storage', 95, true);
+  weightType(POD, -1, true);
+
+  for (const key in WORKLOAD_TYPES) {
+    componentForType(WORKLOAD_TYPES[key], WORKLOAD);
+  }
+
+  ignoreType('events.k8s.io.event'); // Old, moved into core
+  ignoreType('extensions.ingress'); // Old, moved into networking
+  ignoreType(MANAGEMENT.PROJECT);
+  ignoreType(NAMESPACE);
+  ignoreType(MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING);
+  ignoreType(MANAGEMENT.PROJECT_ROLE_TEMPLATE_BINDING);
+
+  mapGroup(/^(core)?$/, 'core');
+  mapGroup('apps', 'apps');
+  mapGroup('batch', 'Batch');
+  mapGroup('autoscaling', 'Autoscaling');
+  mapGroup('policy', 'Policy');
+  mapGroup('networking.k8s.io', 'Networking');
+  mapGroup(/^(.+\.)?api(server)?.*\.k8s\.io$/, 'API');
+  mapGroup('rbac.authorization.k8s.io', 'RBAC');
+  mapGroup('admissionregistration.k8s.io', 'admission');
+  mapGroup('crd.projectcalico.org', 'Calico');
+  mapGroup(/^(.+\.)?cert-manager\.(k8s\.)?io$/, 'Cert Manager');
+  mapGroup(/^(.+\.)?(gateway|gloo)\.solo\.io$/, 'Gloo');
+  mapGroup(/^(.*\.)?monitoring\.coreos\.com$/, 'Monitoring');
+  mapGroup(/^(.*\.)?tekton\.dev$/, 'Tekton');
+  mapGroup(/^(.*\.)?tigera\.io$/, 'Tigera');
+  mapGroup(/^(.*\.)?longhorn(\.rancher)?\.io$/, 'Longhorn');
+  mapGroup(/^(.*\.)?(fleet|gitjob)\.cattle\.io$/, 'Fleet');
+  mapGroup(/^(.*\.)?(helm|k3s)\.cattle\.io$/, 'K3s');
+  mapGroup(/^(.*\.)?upgrade\.cattle\.io$/, 'Upgrade Controller');
+  mapGroup(/^(.*\.)?cis\.cattle\.io$/, 'CIS');
+  mapGroup(/^(.*\.)?traefik\.containo\.us$/, 'Træfik');
+  mapGroup(/^(catalog|management|project|ui)\.cattle\.io$/, 'Rancher');
+  mapGroup(/^(.*\.)?istio\.io$/, 'Istio');
+  mapGroup('split.smi-spec.io', 'SMI');
+  mapGroup(/^(.*\.)*knative\.(io|dev)$/, 'Knative');
+  mapGroup('argoproj.io', 'Argo');
+  mapGroup('logging.banzaicloud.io', 'Logging');
+  mapGroup(/^(.*\.)?resources\.cattle\.io$/, 'Backup-Restore');
+  mapGroup(/^(.*\.)?cluster\.x-k8s\.io$/, 'clusterProvisioning');
+  mapGroup(/^(aks|eks|gke|rke|rke-machine-config|provisioning)\.cattle\.io$/, 'clusterProvisioning');
+
+  configureType(NODE, { isCreatable: false, isEditable: true });
+  configureType(WORKLOAD_TYPES.JOB, { isEditable: false, match: WORKLOAD_TYPES.JOB });
+  configureType(MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING, { isEditable: false });
+  configureType(MANAGEMENT.PROJECT_ROLE_TEMPLATE_BINDING, { isEditable: false, depaginate: true });
+  configureType(MANAGEMENT.PROJECT, { displayName: store.getters['i18n/t']('namespace.project.label') });
+  configureType(NORMAN.PROJECT_ROLE_TEMPLATE_BINDING, { depaginate: true });
+
+  configureType(EVENT, { limit: 500 });
+
+  // Allow Pods to be grouped by node
+  configureType(POD, {
+    listGroups: [
+      {
+        icon:       'icon-cluster',
+        value:      'node',
+        field:      'groupByNode',
+        hideColumn: NODE_COL.name,
+        tooltipKey: 'resourceTable.groupBy.node'
+      }
+    ]
+  });
+
+  setGroupDefaultType('serviceDiscovery', SERVICE);
+
+  configureType('workload', {
+    displayName: 'Workload',
+    location:    {
+      name:    'c-cluster-product-resource',
+      params:  { resource: 'workload' },
+    },
+    resource: WORKLOAD_TYPES.DEPLOYMENT
+  });
+
+  headers(PV, [STATE, NAME_COL, RECLAIM_POLICY, PERSISTENT_VOLUME_CLAIM, PERSISTENT_VOLUME_SOURCE, PV_REASON, AGE]);
+  headers(CONFIG_MAP, [NAME_COL, NAMESPACE_COL, KEYS, AGE]);
+  headers(SECRET, [
+    STATE,
+    NAME_COL,
+    NAMESPACE_COL,
+    SUB_TYPE,
+    {
+      name:      'data',
+      labelKey:  'tableHeaders.data',
+      value:     'dataPreview',
+      formatter: 'SecretData'
+    },
+    AGE
+  ]);
+  headers(INGRESS, [STATE, NAME_COL, NAMESPACE_COL, INGRESS_TARGET, INGRESS_DEFAULT_BACKEND, AGE]);
+  headers(SERVICE, [STATE, NAME_COL, NAMESPACE_COL, TARGET_PORT, SELECTOR, SPEC_TYPE, AGE]);
+  headers(HPA, [STATE, NAME_COL, HPA_REFERENCE, MIN_REPLICA, MAX_REPLICA, CURRENT_REPLICA, AGE]);
+
+  headers(WORKLOAD, [STATE, NAME_COL, NAMESPACE_COL, TYPE, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.DEPLOYMENT, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Ready', 'Up-to-date', 'Available', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.DAEMON_SET, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Ready', 'Current', 'Desired', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.REPLICA_SET, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Ready', 'Current', 'Desired', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.STATEFUL_SET, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Ready', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.JOB, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Completions', 'Duration', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.CRON_JOB, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Schedule', 'Last Schedule', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(WORKLOAD_TYPES.REPLICATION_CONTROLLER, [STATE, NAME_COL, NAMESPACE_COL, WORKLOAD_IMAGES, WORKLOAD_ENDPOINTS, 'Ready', 'Current', 'Desired', POD_RESTARTS, AGE, WORKLOAD_HEALTH_SCALE]);
+  headers(POD, [STATE, NAME_COL, NAMESPACE_COL, POD_IMAGES, 'Ready', 'Restarts', 'IP', NODE_COL, AGE]);
+  headers(STORAGE_CLASS, [STATE, NAME_COL, STORAGE_CLASS_PROVISIONER, STORAGE_CLASS_DEFAULT, AGE]);
+
+  headers(RBAC.ROLE, [
+    STATE,
+    NAME_COL,
+    NAMESPACE_COL,
+    AGE
+  ]);
+
+  headers(RBAC.CLUSTER_ROLE, [
+    STATE,
+    NAME_COL,
+    AGE
+  ]);
+
+  headers(MANAGEMENT.USER, [
+    STATE,
+    USER_ID,
+    USER_DISPLAY_NAME,
+    USER_PROVIDER,
+    USERNAME,
+    AGE
+  ]);
+
+  headers(NORMAN.TOKEN, [
+    EXPIRY_STATE,
+    ACCESS_KEY,
+    DESCRIPTION,
+    SCOPE_NORMAN,
+    EXPIRES,
+    AGE_NORMAN
+  ]);
+
+  virtualType({
+    label:       store.getters['i18n/t']('clusterIndexPage.header'),
+    group:      'Root',
+    namespaced:  false,
+    name:        'cluster-dashboard',
+    weight:      100,
+    route:       { name: 'c-cluster-explorer' },
+    exact:       true,
+    overview:    true,
+  });
+
+  virtualType({
+    label:       store.getters['i18n/t']('members.clusterMembers'),
+    group:      'cluster',
+    namespaced:  false,
+    name:        VIRTUAL_TYPES.CLUSTER_MEMBERS,
+    icon:       'globe',
+    weight:      -1,
+    route:       { name: 'c-cluster-product-members' },
+    exact:       true,
+    ifHaveType:  {
+      type:   MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING,
+      store: 'management'
+    }
+  });
+
+  virtualType({
+    label:          store.getters['i18n/t'](`typeLabel.${ WORKLOAD }`, { count: 2 }),
+    group:          store.getters['i18n/t'](`typeLabel.${ WORKLOAD }`, { count: 2 }),
+    namespaced:     true,
+    name:           WORKLOAD,
+    weight:         99,
+    icon:           'folder',
+    ifHaveSubTypes: Object.values(WORKLOAD_TYPES),
+    route:          {
+      name:     'c-cluster-product-resource',
+      params:   { resource: WORKLOAD }
+    },
+    overview: true,
+  });
+
+  virtualType({
+    label:            store.getters['i18n/t']('projectNamespaces.label'),
+    group:            'cluster',
+    icon:             'globe',
+    namespaced:       false,
+    ifRancherCluster: true,
+    name:             VIRTUAL_TYPES.PROJECT_NAMESPACES,
+    weight:           98,
+    route:            { name: 'c-cluster-product-projectsnamespaces' },
+    exact:            true,
+  });
+
+  virtualType({
+    label:            store.getters['i18n/t'](`typeLabel.${ NAMESPACE }`, { count: 2 }),
+    group:            'cluster',
+    icon:             'globe',
+    namespaced:       false,
+    ifRancherCluster: false,
+    name:             VIRTUAL_TYPES.NAMESPACES,
+    weight:           98,
+    route:            { name: 'c-cluster-product-namespaces' },
+    exact:            true,
+  });
+
+  // Ignore these types as they are managed through the settings product
+  ignoreType(MANAGEMENT.FEATURE);
+  ignoreType(MANAGEMENT.SETTING);
+
+  // Don't show Tokens/API Keys in the side navigation
+  ignoreType(MANAGEMENT.TOKEN);
+  ignoreType(NORMAN.TOKEN);
+
+  // Ignore these types as they are managed through the auth product
+  ignoreType(MANAGEMENT.USER);
+
+  // Ignore these types as they are managed through the auth product
+  ignoreType(MANAGEMENT.GLOBAL_ROLE);
+  ignoreType(MANAGEMENT.ROLE_TEMPLATE);
+}

package/config/product/fleet.js

@@ -0,0 +1,90 @@
+import { DSL } from '@shell/store/type-map';
+import { FLEET } from '@shell/config/types';
+import { STATE, NAME as NAME_COL, AGE } from '@shell/config/table-headers';
+import { FLEET as FLEET_FEATURE } from '@shell/store/features';
+
+export const NAME = 'fleet';
+export const CHART_NAME = 'fleet';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    weightType,
+    configureType,
+    headers,
+    // mapType,
+    virtualType,
+  } = DSL(store, NAME);
+
+  product({
+    ifHaveType:            FLEET.GIT_REPO,
+    ifFeature:             FLEET_FEATURE,
+    icon:                  'fleet',
+    inStore:               'management',
+    removable:             false,
+    showClusterSwitcher:   false,
+    showWorkspaceSwitcher: true,
+  });
+
+  virtualType({
+    label:        store.getters['i18n/t']('fleet.dashboard.menuLabel'),
+    icon:         'folder',
+    group:        'Root',
+    namespaced:   false,
+    name:         FLEET.DASHBOARD,
+    weight:       110,
+    route:        {
+      name:   'c-cluster-fleet',
+      params: { resource: FLEET.DASHBOARD }
+    },
+    exact: true,
+  });
+
+  basicType([
+    FLEET.DASHBOARD,
+    FLEET.CLUSTER,
+    FLEET.CLUSTER_GROUP,
+    FLEET.GIT_REPO,
+  ]);
+
+  configureType(FLEET.CLUSTER, { isCreatable: false });
+  configureType(FLEET.GIT_REPO, { showListMasthead: false });
+
+  weightType(FLEET.GIT_REPO, 109, true);
+  weightType(FLEET.CLUSTER, 108, true);
+  weightType(FLEET.CLUSTER_GROUP, 107, true);
+
+  basicType([
+    FLEET.WORKSPACE,
+    FLEET.BUNDLE,
+    FLEET.TOKEN,
+  ], 'advanced');
+
+  headers(FLEET.WORKSPACE, [
+    STATE,
+    NAME_COL,
+    {
+      name:      'gitRepos',
+      labelKey:  'tableHeaders.gitRepos',
+      value:     'counts.gitRepos',
+      sort:      'counts.gitRepos',
+      formatter: 'Number',
+    },
+    {
+      name:      'clusters',
+      labelKey:  'tableHeaders.clusters',
+      value:     'counts.clusters',
+      sort:      'counts.clusters',
+      formatter: 'Number',
+    },
+    {
+      name:      'clusterGroups',
+      labelKey:  'tableHeaders.clusterGroups',
+      value:     'counts.clusterGroups',
+      sort:      'counts.clusterGroups',
+      formatter: 'Number',
+    },
+    AGE
+  ]);
+}

package/config/product/gatekeeper.js

@@ -0,0 +1,119 @@
+import { DSL } from '@shell/store/type-map';
+import { GATEKEEPER, OBJECT_META } from '@shell/config/types';
+import { AGE, NAME as NAME_COL, STATE } from '@shell/config/table-headers';
+import { findAllConstraints } from '@shell/utils/gatekeeper/util';
+
+export const NAME = 'gatekeeper';
+export const CHART_NAME = 'rancher-gatekeeper';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    groupBy,
+    headers,
+    mapGroup,
+    mapType,
+    spoofedType,
+    virtualType
+  } = DSL(store, NAME);
+
+  product({
+    ifHaveGroup: /^(.*\.)?gatekeeper\.sh$/,
+    icon:        'gatekeeper',
+  });
+
+  mapGroup(/^(.*\.)?gatekeeper\.sh$/, 'OPA Gatekeeper');
+  mapType(/^templates\.gatekeeper\.sh\.constrainttemplate$/, 'Template');
+  mapType(GATEKEEPER.SPOOFED.CONSTRAINT, 'Constraint');
+
+  basicType([
+    'gatekeeper-overview',
+    'gatekeeper-constraint',
+    'gatekeeper-template',
+    GATEKEEPER.SPOOFED.CONSTRAINT,
+    GATEKEEPER.CONSTRAINT_TEMPLATE
+  ]);
+
+  spoofedType({
+    label:             'Constraints',
+    type:              GATEKEEPER.SPOOFED.CONSTRAINT,
+    collectionMethods: ['POST'],
+    schemas:           [
+      {
+        id:                GATEKEEPER.SPOOFED.CONSTRAINT,
+        type:              'schema',
+        collectionMethods: ['POST'],
+        resourceFields:    {
+          metadata: { type: OBJECT_META },
+          spec:     { type: 'json' },
+          kind:     { type: 'string' }
+        }
+      }
+    ],
+    getInstances: async() => {
+      const rawConstraints = await findAllConstraints(store);
+
+      return rawConstraints
+        .flat()
+        .map((constraint) => {
+          return {
+            id:          constraint.id,
+            kind:        constraint.kind,
+            type:        GATEKEEPER.SPOOFED.CONSTRAINT,
+            spec:        constraint.spec,
+            metadata:    constraint.metadata,
+            status:      constraint.status,
+            links:       {
+              self: constraint.links.self,
+              view: constraint.links.view
+            },
+            constraint
+          };
+        });
+    }
+  });
+
+  virtualType({
+    label:      'Overview',
+    namespaced: false,
+    name:       'gatekeeper-overview',
+    route:      { name: 'c-cluster-gatekeeper' },
+    exact:      true,
+    weight:     3,
+    overview:   true,
+  });
+
+  headers(GATEKEEPER.CONSTRAINT_TEMPLATE, [
+    STATE,
+    NAME_COL,
+    {
+      name:  'Kind',
+      label: 'Kind',
+      value: 'kind',
+      sort:  'kind'
+    },
+    AGE,
+  ]);
+
+  headers(GATEKEEPER.SPOOFED.CONSTRAINT, [
+    STATE,
+    NAME_COL,
+    {
+      name:  'Description',
+      label: 'Description',
+      value: `description`,
+      sort:  `description`
+    },
+    {
+      name:  'Violations',
+      label: 'Violations',
+      value: 'status.totalViolations',
+      sort:  'status.totalViolations',
+      width: 120
+    },
+    AGE,
+  ]);
+
+  groupBy(GATEKEEPER.SPOOFED.CONSTRAINT, 'kind');
+}