@rancher/shell 0.1.0

package/config/labels-annotations.js

@@ -0,0 +1,180 @@
+export const NORMAN_NAME = 'field.cattle.io/name';
+export const DESCRIPTION = 'field.cattle.io/description';
+export const HOSTNAME = 'kubernetes.io/hostname';
+export const TIMESTAMP = 'cattle.io/timestamp';
+export const SYSTEM_NAMESPACE = 'management.cattle.io/system-namespace';
+export const PROJECT = 'field.cattle.io/projectId';
+export const DEFAULT_PROJECT = 'authz.management.cattle.io/default-project';
+export const SYSTEM_PROJECT = 'authz.management.cattle.io/system-project';
+export const CONTAINER_DEFAULT_RESOURCE_LIMIT = 'field.cattle.io/containerDefaultResourceLimit';
+export const CATTLE_PUBLIC_ENDPOINTS = 'field.cattle.io/publicEndpoints';
+export const TARGET_WORKLOADS = 'field.cattle.io/targetWorkloadIds';
+export const UI_MANAGED = 'management.cattle.io/ui-managed';
+export const CREATOR_ID = 'field.cattle.io/creatorId';
+export const RESOURCE_QUOTA = 'field.cattle.io/resourceQuota';
+
+export const KUBERNETES = {
+  SERVICE_ACCOUNT_UID:  'kubernetes.io/service-account.uid',
+  SERVICE_ACCOUNT_NAME: 'kubernetes.io/service-account.name',
+  MANAGED_BY:           'app.kubernetes.io/managed-by',
+  MANAGED_NAME:         'app.kubernetes.io/name',
+  INSTANCE:             'app.kubernetes.io/instance',
+};
+
+export const CERTMANAGER = { ISSUER: 'cert-manager.io/issuer-name' };
+
+export const STORAGE = {
+  DEFAULT_STORAGE_CLASS:      'storageclass.kubernetes.io/is-default-class',
+  BETA_DEFAULT_STORAGE_CLASS: 'storageclass.beta.kubernetes.io/is-default-class'
+};
+
+export const MANAGEMENT_NODE = { NODE_NAME: 'management.cattle.io/nodename' };
+
+export const NODE_ROLES = {
+  CONTROL_PLANE_OLD: 'node-role.kubernetes.io/controlplane',
+  CONTROL_PLANE:     'node-role.kubernetes.io/control-plane',
+  WORKER:            'node-role.kubernetes.io/worker',
+  ETCD:              'node-role.kubernetes.io/etcd',
+};
+
+export const MACHINE_ROLES = {
+  CONTROL_PLANE: 'rke.cattle.io/control-plane-role',
+  WORKER:        'rke.cattle.io/worker-role',
+  ETCD:          'rke.cattle.io/etcd-role',
+};
+
+export const CAPI = {
+  DEPLOYMENT_NAME:      'cluster.x-k8s.io/deployment-name',
+  CREDENTIAL_DRIVER:    'provisioning.cattle.io/driver',
+  CLUSTER_NAMESPACE:    'cluster.x-k8s.io/cluster-namespace',
+  FORCE_MACHINE_REMOVE: 'provisioning.cattle.io/force-machine-remove',
+  MACHINE_NAME:         'cluster.x-k8s.io/machine',
+  DELETE_MACHINE:       'cluster.x-k8s.io/delete-machine',
+  PROVIDER:             'provider.cattle.io'
+};
+
+export const CATALOG = {
+  CERTIFIED:     'catalog.cattle.io/certified',
+  _RANCHER:      'rancher',
+  _PARTNER:      'partner',
+  _OTHER:         'other',
+
+  EXPERIMENTAL:  'catalog.cattle.io/experimental',
+  NAMESPACE:     'catalog.cattle.io/namespace',
+  RELEASE_NAME:  'catalog.cattle.io/release-name',
+
+  REQUIRES_GVK:     'catalog.cattle.io/requires-gvr',
+  PROVIDES:         'catalog.cattle.io/provides-gvr',
+  AUTO_INSTALL_GVK: 'catalog.cattle.io/auto-install-gvr',
+  AUTO_INSTALL:     'catalog.cattle.io/auto-install',
+  HIDDEN:           'catalog.cattle.io/hidden',
+  REQUESTS_CPU:     'catalog.cattle.io/requests-cpu',
+  REQUESTS_MEMORY:  'catalog.cattle.io/requests-memory',
+
+  SCOPE:            'catalog.cattle.io/scope',
+  _MANAGEMENT:      'management',
+  _DOWNSTREAM:      'downstream',
+
+  TYPE:             'catalog.cattle.io/type',
+  _APP:             'app',
+  _CLUSTER_TPL:     'cluster-template',
+  _CLUSTER_TOOL:    'cluster-tool',
+
+  COMPONENT:        'catalog.cattle.io/ui-component',
+  SOURCE_REPO_TYPE: 'catalog.cattle.io/ui-source-repo-type',
+  SOURCE_REPO_NAME: 'catalog.cattle.io/ui-source-repo',
+  COLOR:            'catalog.cattle.io/ui-color',
+  DISPLAY_NAME:     'catalog.cattle.io/display-name',
+
+  SUPPORTED_OS: 'catalog.cattle.io/os',
+  PERMITTED_OS: 'catalog.cattle.io/permits-os',
+  DEPLOYED_OS:   'catalog.cattle.io/deploys-on-os',
+
+  MIGRATED: 'apps.cattle.io/migrated',
+  MANAGED:  'catalog.cattle.io/managed'
+};
+
+export const FLEET = {
+  CLUSTER_DISPLAY_NAME: 'management.cattle.io/cluster-display-name',
+  CLUSTER_NAME:         'management.cattle.io/cluster-name',
+  BUNDLE_ID:            'fleet.cattle.io/bundle-id',
+  MANAGED:              'fleet.cattle.io/managed'
+};
+
+export const RBAC = { PRODUCT: 'management.cattle.io/ui-product' };
+
+export const RKE = { EXTERNAL_IP: 'rke.cattle.io/external-ip' };
+
+export const SNAPSHOT = { CLUSTER_NAME: 'rke.cattle.io/cluster-name' };
+
+export const ISTIO = { AUTO_INJECTION: 'istio-injection' };
+
+const CATTLE_REGEX = /cattle\.io\//;
+
+export const LABELS_TO_IGNORE_REGEX = [
+  CATTLE_REGEX
+];
+
+export const ANNOTATIONS_TO_IGNORE_REGEX = [
+  CATTLE_REGEX
+];
+
+export const ANNOTATIONS_TO_FOLD = [
+  /^kubectl\.kubernetes\.io\/.*$/,
+  /^objectset\.rio\.cattle\.io\/.*$/,
+];
+
+export const HCI = {
+  CLUSTER_ID:                   'harvesterhci.io/clusterId',
+  CLOUD_INIT:                   'harvesterhci.io/cloud-init-template',
+  CURRENT_IP:                   'rke2.io/internal-ip',
+  OWNED_BY:                     'harvesterhci.io/owned-by',
+  CREATED_BY:                   'kubevirt.io/created-by',
+  IMAGE_ID:                     'harvesterhci.io/imageId',
+  SSH_NAMES:                    'harvesterhci.io/sshNames',
+  CIRD_NETWORK:                 'k8s.v1.cni.cncf.io/networks',
+  NETWORK_IPS:                  'network.harvesterhci.io/ips',
+  TEMPLATE_VERSION_CUSTOM_NAME: 'template-version.harvesterhci.io/customName',
+  CREATOR:                      'harvesterhci.io/creator',
+  OS:                           'harvesterhci.io/os',
+  NETWORK_TYPE:                 'network.harvesterhci.io/type',
+  VM_NAME:                      'harvesterhci.io/vmName',
+  VM_NAME_PREFIX:               'harvesterhci.io/vmNamePrefix',
+  VM_RESERVED_MEMORY:           'harvesterhci.io/reservedMemory',
+  MAINTENANCE_STATUS:           'harvesterhci.io/maintain-status',
+  HOST_CUSTOM_NAME:             'harvesterhci.io/host-custom-name',
+  HOST_CONSOLE_URL:             'harvesterhci.io/host-console-url',
+  BACKUP_TARGET:                'backup.harvesterhci.io/backup-target',
+  RESTORE_NAME:                 'restore.harvesterhci.io/name',
+  NODE_ROLE_MASTER:             'node-role.kubernetes.io/master',
+  NODE_ROLE_CONTROL_PLANE:      'node-role.kubernetes.io/control-plane',
+  PROMOTE_STATUS:               'harvesterhci.io/promote-status',
+  MIGRATION_STATE:              'harvesterhci.io/migrationState',
+  VOLUME_CLAIM_TEMPLATE:        'harvesterhci.io/volumeClaimTemplates',
+  IMAGE_NAME:                   'harvesterhci.io/image-name',
+  INIT_IP:                      'etcd.rke2.cattle.io/node-address',
+  NODE_SCHEDULABLE:             'kubevirt.io/schedulable',
+  NETWORK_ROUTE:                'network.harvesterhci.io/route',
+  CLOUD_PROVIDER_IPAM:          'cloudprovider.harvesterhci.io/ipam',
+  OS_UPGRADE_IMAGE:             'harvesterhci.io/os-upgrade-image',
+  UPGRADE_IMAGE:                'harvesterhci.io/upgradeImage',
+  LATEST_UPGRADE:               'harvesterhci.io/latestUpgrade',
+  UPGRADE_STATE:                'harvesterhci.io/upgradeState',
+  REAY_MESSAGE:                 'harvesterhci.io/read-message',
+  DYNAMIC_SSHKEYS_NAMES:        'harvesterhci.io/dynamic-ssh-key-names',
+  DYNAMIC_SSHKEYS_USERS:        'harvesterhci.io/dynamic-ssh-key-users',
+  VM_VOLUME_STATUS:             'harvesterhci.io/volume-status',
+  IMAGE_SUFFIX:                 'harvesterhci.io/image-type',
+  OS_TYPE:                      'harvesterhci.io/os-type'
+};
+
+// Annotations that can be on management.cattle.io.cluster to configure a custom badge
+// Can't use ui.cattle.io - it seems to strip these out - so using io.rancher
+export const CLUSTER_BADGE = {
+  // Badge text - badge is only shown if badge text is not empty
+  TEXT:        'ui.rancher/badge-text',
+  // Badge color - as a hex color - e.g. #ff00ff
+  COLOR:       'ui.rancher/badge-color',
+  // Custom icon text - max 2 characters
+  ICON_TEXT:   'ui.rancher/badge-icon-text',
+};

package/config/local-storage.js

@@ -0,0 +1,6 @@
+// Github repo cache
+export const GITHUB_REPOS = 'githubRepos';
+export const GITHUB_SCOPES = 'githubScopes';
+export const _DATE = 'Updated';
+
+export const BACK_TO = 'backTo';

package/config/nuxt-paths.js

@@ -0,0 +1,7 @@
+export const CLUSTER_PATH = {
+  ROOT:         'c-cluster',
+  PRODUCT:      'c-cluster-product',
+  RESOURCE:     'c-cluster-product-resource',
+  RESOURCE_ID:  'c-cluster-product-resource-id',
+  NAMESPACE_ID: 'c-cluster-product-resource-namespace-id',
+};

package/config/page-actions.js

@@ -0,0 +1,3 @@
+export const RESET_CARDS_ACTION = 'reset-homepage-cards';
+export const SET_LOGIN_ACTION = 'set-as-login';
+export const ADD_CUSTOM_NAV_LINK = 'add-custom-nav-link';

package/config/private-label.js

@@ -0,0 +1,70 @@
+import { SETTING } from './settings';
+
+export const ANY = 0;
+export const STANDARD = 1;
+export const CUSTOM = 2;
+export const DOCS_BASE = 'https://rancher.com/docs/rancher/v2.6/en';
+
+const STANDARD_VENDOR = 'Rancher';
+const STANDARD_PRODUCT = 'Explorer';
+const CUSTOM_VENDOR = { suse: 'SUSE Rancher' };
+
+let mode = STANDARD;
+let vendor = STANDARD_VENDOR;
+let product = STANDARD_PRODUCT;
+let brand = null;
+
+export function setMode(m) {
+  mode = m;
+}
+
+export function setVendor(v) {
+  vendor = v;
+}
+
+export function setProduct(p) {
+  product = p;
+}
+
+export function setBrand(b) {
+  brand = b;
+}
+
+// -------------------------------------
+
+export function getMode() {
+  return mode;
+}
+
+export function getBrand() {
+  return brand;
+}
+
+export function isStandard() {
+  return mode === STANDARD;
+}
+
+export function matches(pl) {
+  if ( pl === ANY ) {
+    return true;
+  }
+
+  return pl === mode;
+}
+
+export function getVendor() {
+  if ( vendor === SETTING.PL_RANCHER_VALUE ) {
+    // Custom vendor override based on brand
+    if (brand && CUSTOM_VENDOR[brand]) {
+      return CUSTOM_VENDOR[brand];
+    }
+
+    return STANDARD_VENDOR;
+  }
+
+  return vendor;
+}
+
+export function getProduct() {
+  return product;
+}

package/config/product/apps.js

@@ -0,0 +1,115 @@
+import {
+  AGE,
+  STATE,
+  CHART,
+  CHART_UPGRADE,
+  NAMESPACE,
+  NAME as NAME_COL,
+  APP_SUMMARY,
+} from '@shell/config/table-headers';
+
+import { CATALOG } from '@shell/config/types';
+import { DSL } from '@shell/store/type-map';
+
+export const NAME = 'apps';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    headers,
+    virtualType,
+    weightType,
+    configureType,
+  } = DSL(store, NAME);
+
+  product({
+    removable:           false,
+    weight:              97,
+    ifHaveGroup:         'catalog.cattle.io',
+    icon:                'marketplace',
+    showNamespaceFilter: true
+  });
+
+  virtualType({
+    label:       'Charts',
+    icon:       'compass',
+    namespaced:  false,
+    name:        'charts',
+    weight:      100,
+    route:       { name: 'c-cluster-apps-charts' },
+  });
+
+  weightType(CATALOG.APP, 99, true);
+
+  basicType([
+    'charts',
+    CATALOG.APP,
+    CATALOG.OPERATION,
+    CATALOG.CLUSTER_REPO,
+    CATALOG.REPO,
+  ]);
+
+  configureType(CATALOG.APP, { isCreatable: false, isEditable: false });
+  configureType(CATALOG.OPERATION, { isCreatable: false, isEditable: false });
+
+  const repoType = {
+    name:     'type',
+    labelKey: 'tableHeaders.type',
+    sort:     'typeDisplay',
+    value:    'typeDisplay'
+  };
+
+  const repoUrl = {
+    name:     'url',
+    labelKey: 'tableHeaders.url',
+    sort:     'urlDisplay',
+    value:    'urlDisplay'
+  };
+
+  const repoBranch = {
+    name:        'branch',
+    labelKey:    'tableHeaders.branch',
+    sort:        'spec.gitBranch',
+    value:       'spec.gitBranch',
+    dashIfEmpty: true,
+  };
+
+  headers(CATALOG.APP, [STATE, NAME_COL, NAMESPACE, CHART, CHART_UPGRADE, APP_SUMMARY, AGE]);
+  headers(CATALOG.REPO, [STATE, NAME_COL, NAMESPACE, repoType, repoUrl, repoBranch, AGE]);
+  headers(CATALOG.CLUSTER_REPO, [STATE, NAME_COL, repoType, repoUrl, repoBranch, AGE]);
+  headers(CATALOG.OPERATION, [
+    STATE,
+    NAME_COL,
+    NAMESPACE,
+    {
+      name:     'action',
+      label:    'Action',
+      sort:     'status.action',
+      value:    'status.action',
+      labelKey: 'catalog.operation.tableHeaders.action',
+    },
+    {
+      name:     'releaseNamespace',
+      label:    'Tgt Namespace',
+      sort:     'status.namespace',
+      value:    'status.namespace',
+      labelKey: 'catalog.operation.tableHeaders.releaseNamespace',
+    },
+    {
+      name:     'releaseName',
+      label:    'Tgt Release',
+      sort:     'status.releaseName',
+      value:    'status.releaseName',
+      labelKey: 'catalog.operation.tableHeaders.releaseName',
+    },
+    AGE
+  ]);
+}
+
+//   name:      'cpu',
+//   labelKey:  'tableHeaders.cpu',
+//   sort:      'cpu',
+//   value:     'cpuUsagePercentage',
+//   formatter: 'PercentageBar'
+// };

package/config/product/auth.js

@@ -0,0 +1,215 @@
+import { DSL } from '@shell/store/type-map';
+import { MANAGEMENT, NORMAN } from '@shell/config/types';
+import { uniq } from '@shell/utils/array';
+import {
+  GROUP_NAME, GROUP_ROLE_NAME,
+  RBAC_BUILTIN, RBAC_DEFAULT, STATE, NAME as HEADER_NAME, AGE, SIMPLE_NAME
+} from '@shell/config/table-headers';
+import { MULTI_CLUSTER } from '@shell/store/features';
+
+export const NAME = 'auth';
+
+const USERS_VIRTUAL_TYPE = 'users';
+const ROLES_VIRTUAL_TYPE = 'roles';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    weightType,
+    configureType,
+    componentForType,
+    headers,
+    mapType,
+    spoofedType,
+    virtualType,
+  } = DSL(store, NAME);
+
+  product({
+    ifHaveType:          new RegExp(`${ MANAGEMENT.USER }|${ MANAGEMENT.AUTH_CONFIG }`, 'i'),
+    ifHaveVerb:          'PUT',
+    ifFeature:           MULTI_CLUSTER,
+    inStore:             'management',
+    icon:                'user',
+    removable:           false,
+    showClusterSwitcher: false,
+    category:            'configuration',
+  });
+
+  virtualType({
+    labelKey:    'auth.config.label',
+    icon:        'lock',
+    namespaced:  false,
+    name:        'config',
+    weight:      -1,
+    route:       { name: 'c-cluster-auth-config' },
+    ifHaveType: MANAGEMENT.AUTH_CONFIG
+  });
+
+  virtualType({
+    label:       store.getters['type-map/labelFor']({ id: MANAGEMENT.USER }, 2),
+    name:           USERS_VIRTUAL_TYPE,
+    namespaced:     false,
+    weight:         102,
+    icon:           'user',
+    route:          {
+      name:   'c-cluster-product-resource',
+      params: {
+        cluster:  'local',
+        product:  NAME,
+        resource: MANAGEMENT.USER,
+      }
+    }
+  });
+  configureType(MANAGEMENT.USER, { showListMasthead: false });
+
+  spoofedType({
+    label:             store.getters['type-map/labelFor']({ id: NORMAN.SPOOFED.GROUP_PRINCIPAL }, 2),
+    type:              NORMAN.SPOOFED.GROUP_PRINCIPAL,
+    ifHaveType:        MANAGEMENT.GLOBAL_ROLE_BINDING,
+    collectionMethods: [],
+    schemas:           [
+      {
+        id:                NORMAN.SPOOFED.GROUP_PRINCIPAL,
+        type:              'schema',
+        collectionMethods: [],
+        resourceFields:    {},
+      }
+    ],
+    getInstances: async() => {
+      // Determine if the user can get fetch global roles & global role bindings. If not there's not much point in showing the table
+      const canFetchGlobalRoles = !!store.getters[`management/canList`](MANAGEMENT.GLOBAL_ROLE);
+      const canFetchGlobalRoleBindings = !!store.getters[`management/canList`](MANAGEMENT.GLOBAL_ROLE_BINDING);
+
+      if (!canFetchGlobalRoles || !canFetchGlobalRoleBindings) {
+        return [];
+      }
+
+      // Ensure we upfront load principals (saves making individual requests later)
+      await store.dispatch('rancher/findAll', {
+        type: NORMAN.PRINCIPAL,
+        opt:  { url: '/v3/principals' }
+      });
+
+      // getInstances should return a list of principals that have global bindings.
+      // It would be easier to just filter principals from above by those with bindings...
+      // .. however the principals list from above is NOT complete and misses some that have bindings (seen when using AD)
+      // So flip the logic and fetch any principal that's missing from the principal list
+
+      const globalRoleBindings = await store.dispatch('management/findAll', {
+        type: MANAGEMENT.GLOBAL_ROLE_BINDING,
+        opt:  { force: true }
+      });
+
+      const uniquePrincipalIds = uniq(globalRoleBindings
+        .filter(grb => !!grb.groupPrincipalName)
+        .map(grb => grb.groupPrincipalName)
+      );
+
+      const allPrincipalsP = uniquePrincipalIds
+        .map(async(pId) => {
+          // Guard against principals that aren't retrievable (bindings to principals from previous auth providers)
+          try {
+            return await store.dispatch('rancher/find', {
+              type: NORMAN.PRINCIPAL,
+              opt:  { url: `/v3/principals/${ encodeURIComponent(pId) }` },
+              id:   pId
+            });
+          } catch (e) {
+            console.warn(`Failed to fetch Principal with id: '${ pId }'`, e); // eslint-disable-line no-console
+          }
+        });
+
+      const allPrincipals = await Promise.all(allPrincipalsP);
+
+      return allPrincipals
+        .filter(p => !!p)
+        .map(p => ({
+          ...p,
+          type: NORMAN.SPOOFED.GROUP_PRINCIPAL
+        }));
+    }
+  });
+  configureType(NORMAN.SPOOFED.GROUP_PRINCIPAL, {
+    isCreatable:      false,
+    showAge:          false,
+    showState:        false,
+    isRemovable:      false,
+    showListMasthead: false,
+  });
+  // Use labelFor... so lookup succeeds with .'s in path.... and end result is 'trimmed' as per other entries
+  mapType(NORMAN.SPOOFED.GROUP_PRINCIPAL, store.getters['type-map/labelFor']({ id: NORMAN.SPOOFED.GROUP_PRINCIPAL }, 2));
+  weightType(NORMAN.SPOOFED.GROUP_PRINCIPAL, 101, true);
+
+  virtualType({
+    label:       store.getters['i18n/t']('rbac.roletemplate.label'),
+    icon:        'user',
+    namespaced:  false,
+    name:        ROLES_VIRTUAL_TYPE,
+    weight:      101,
+    route:       { name: 'c-cluster-auth-roles' },
+    // There are two resource types shown on this page, MANAGEMENT.GLOBAL_ROLE and MANAGEMENT.ROLE_TEMPLATE
+    // If there user can't see ROLE_TEMPLATE, they definitely can't see GLOBAL_ROLE
+    ifHaveType:  MANAGEMENT.ROLE_TEMPLATE
+  });
+
+  configureType(MANAGEMENT.AUTH_CONFIG, {
+    isCreatable: false,
+    isRemovable: false,
+    showAge:     false,
+    location:    null,
+  });
+
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/github`, 'auth/github');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/openldap`, 'auth/ldap/index');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/freeipa`, 'auth/ldap/index');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/activedirectory`, 'auth/ldap/index');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/ping`, 'auth/saml');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/shibboleth`, 'auth/saml');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/okta`, 'auth/saml');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/keycloak`, 'auth/saml');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/adfs`, 'auth/saml');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/googleoauth`, 'auth/googleoauth');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/azuread`, 'auth/azuread');
+  componentForType(`${ MANAGEMENT.AUTH_CONFIG }/keycloakoidc`, 'auth/oidc');
+
+  basicType([
+    'config',
+    USERS_VIRTUAL_TYPE,
+    NORMAN.SPOOFED.GROUP_PRINCIPAL,
+    ROLES_VIRTUAL_TYPE
+  ]);
+
+  headers(NORMAN.SPOOFED.GROUP_PRINCIPAL, [
+    GROUP_NAME,
+    GROUP_ROLE_NAME
+  ]);
+
+  // A lot of the built in roles have nicer names returned by nameDisplay. In both tables we want to show both nicer and base names
+  const DISPLAY_NAME = {
+    ...HEADER_NAME,
+    name:          'displayName',
+    labelKey: 'tableHeaders.nameDisplay',
+  };
+
+  headers(MANAGEMENT.GLOBAL_ROLE, [
+    STATE,
+    DISPLAY_NAME,
+    SIMPLE_NAME,
+    RBAC_BUILTIN,
+    {
+      ...RBAC_DEFAULT,
+      labelKey: 'tableHeaders.authRoles.globalDefault',
+    },
+    AGE
+  ]);
+
+  headers(MANAGEMENT.ROLE_TEMPLATE, [
+    STATE,
+    DISPLAY_NAME,
+    SIMPLE_NAME,
+    RBAC_BUILTIN,
+    RBAC_DEFAULT,
+    AGE
+  ]);
+}

package/config/product/backup.js

@@ -0,0 +1,61 @@
+import { DSL } from '@shell/store/type-map';
+import { BACKUP_RESTORE } from '@shell/config/types';
+import { STATE, NAME as NAME_HEADER, AGE } from '@shell/config/table-headers';
+
+export const NAME = 'backup';
+export const CHART_NAME = 'rancher-backup';
+
+export function init(store) {
+  const {
+    product,
+    basicType,
+    weightType,
+    headers
+  } = DSL(store, NAME);
+
+  product({
+    ifHaveGroup: /^(.*\.)*resources\.cattle\.io$/,
+    icon:        'backup-restore',
+  });
+
+  weightType(BACKUP_RESTORE.BACKUP, 99, true);
+  weightType(BACKUP_RESTORE.RESTORE, 98, true);
+
+  basicType([
+    'resources.cattle.io.backup',
+    'resources.cattle.io.restore',
+  ]);
+
+  headers(BACKUP_RESTORE.BACKUP, [
+    { ...STATE, value: 'Status' },
+    NAME_HEADER,
+    'Location',
+    'Type',
+    {
+      name:     'backupFilename',
+      labelKey: 'backupRestoreOperator.backupFilename',
+      value:    'status.filename'
+    },
+    {
+      name:      'nextBackup',
+      labelKey:  'backupRestoreOperator.nextBackup',
+      value:     'status.nextSnapshotAt',
+      formatter: 'Date'
+    },
+    {
+      name:      'nextBackup',
+      labelKey:  'backupRestoreOperator.lastBackup',
+      value:     'status.lastSnapshotTs',
+      formatter: 'Date'
+
+    }
+  ]);
+
+  headers(BACKUP_RESTORE.RESTORE, [
+    { ...STATE, value: 'Status' },
+    NAME_HEADER,
+    'Backup-Source',
+    'Backup-File',
+    AGE,
+  ]);
+}