@rancher/shell 0.3.3 → 0.3.5

package/scripts/extension/bundle

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+
+BASE_DIR="$(pwd)"
+
+CYAN="\033[96m"
+RED="\033[91m"
+RESET="\033[0m"
+BOLD="\033[1m"
+
+TMP=${BASE_DIR}/tmp
+CHART_TEMPLATE=${TMP}/ui-plugin-server
+
+PKG="${1}"
+PKG_VERSION="${2}"
+REGISTRY="${3}"
+REGISTRY_ORG="${4}"
+IMAGE_PREFIX="${5}"
+PUSH="${6}"
+
+PKG_NAME="${PKG}-${PKG_VERSION}"
+
+# --------------------------------------------------------------------------------
+# Create the container image
+# --------------------------------------------------------------------------------
+mkdir -p ${TMP}/container
+cp -R ${CHART_TEMPLATE}/* ${TMP}/container/    
+
+# Copy the plugin assets
+rm -rf ${TMP}/container/plugin
+mkdir ${TMP}/container/plugin
+
+cp -R ${BASE_DIR}/dist-pkg/${PKG_NAME}/* ${TMP}/container/plugin
+rm -f ${TMP}/container/plugin/report.html
+
+# Build the docker image
+pushd ${TMP}/container > /dev/null
+echo -e "${CYAN}Building container image ...${RESET}"
+
+if [ ! -z "${REGISTRY}" ]; then
+  REGISTRY=${REGISTRY} ORG=${REGISTRY_ORG} REPO=${IMAGE_PREFIX}${PKG} TAG=${PKG_VERSION} ./scripts/package
+
+  if [ "${PUSH}" == "--push" ]; then
+    echo -e "${CYAN}Pushing container image ...${RESET}"
+
+    # Ensure that you do not overwrite production images
+    if [[ "${REGISTRY_ORG}" == "rancher" ]]; then
+      IMAGE=${REGISTRY}${REGISTRY_ORG}/${IMAGE_PREFIX}${PKG}:${PKG_VERSION}
+      if docker manifest inspect 2>&1 1>/dev/null; then
+        echo -e "${RED}${BOLD}Cannot overwrite production image ${IMAGE_PREFIX}${PKG} since it already exists${RESET}"
+        exit 1
+      fi
+    fi
+
+    docker push ${REGISTRY}${REGISTRY_ORG}/${IMAGE_PREFIX}${PKG}:${PKG_VERSION}
+  fi
+fi
+
+popd > /dev/null

package/scripts/extension/helmpatch

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+// Update Chart.yaml and values.yaml files
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+// TODO: Should already be in the template
+// const UI_PLUGIN_ANNOTATION_NAME = 'catalog.cattle.io/ui-component';
+// const UI_PLUGIN_ANNOTATION_VALUE = 'plugins';
+
+console.log('Helm file update');
+
+if (process.argv.length !== 5) {
+  console.log('Incorrect number of arguments');
+  process.exit(1);
+}
+
+const destFolder = process.argv[2];
+const pkgFilePath = process.argv[3];
+const image = process.argv[4];
+
+const pkgFile = JSON.parse(fs.readFileSync(pkgFilePath, 'utf8'));
+
+const chartFolder = destFolder;
+const chartFile = path.join(chartFolder, 'Chart.yaml');
+const valuesFile = path.join(chartFolder, 'values.yaml');
+
+if (!fs.existsSync(chartFolder)) {
+  console.log('Charts folder does not exist');
+  process.exit(1);
+}
+
+// --------------------------------------------------------------------------------
+// Chart.yaml
+// --------------------------------------------------------------------------------
+const chart = yaml.load(fs.readFileSync(chartFile, 'utf8'));
+let updated = false;
+
+// Add in annotations to match any rules in the package file
+if (pkgFile.rancher && typeof pkgFile.rancher === 'object') {
+  // See if there are any annotations and merge them in, if there are
+  if (pkgFile.rancher.annotations) {
+    chart.annotations = chart.annotations || {};
+    Object.keys(pkgFile.rancher.annotations).forEach((key) => {
+      chart.annotations[key] = pkgFile.rancher.annotations[key];
+      updated = true;
+    });
+  }
+}
+
+if (updated ){
+  // Write out updated file
+  const str = yaml.dump(chart);
+
+  fs.writeFileSync(chartFile, str, 'utf8');
+}
+
+// chart.name = pkgFile.name;
+// chart.appVersion = pkgFile.version;
+// chart.version = pkgFile.version;
+// chart.description = pkgFile.description || `${pkgFile.name} ui plugin `;
+// chart.annotations[UI_PLUGIN_ANNOTATION_NAME] = UI_PLUGIN_ANNOTATION_VALUE;
+
+// if (pkgFile.icon) {
+//   chart.icon = pkgFile.icon;
+// }
+
+// if (pkgFile.keywords) {
+//   chart.keywords = pkgFile.keywords;
+// } else {
+//   chart.keywords = [];
+// }
+
+// if (pkgFile.homepage) {
+//   chart.home = pkgFile.homepage;
+// }
+
+// --------------------------------------------------------------------------------
+// values.yaml
+// --------------------------------------------------------------------------------
+
+const values = yaml.load(fs.readFileSync(valuesFile, 'utf8'));
+
+values.pluginServer.image.repository = `${image}`;
+
+const valuesYaml = yaml.dump(values, {quotingType: '"' });
+fs.writeFileSync(valuesFile, valuesYaml, 'utf8');

package/scripts/extension/publish

@@ -0,0 +1,314 @@
+#!/usr/bin/env bash
+
+SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+BASE_DIR="$(pwd)"
+
+CYAN="\033[96m"
+YELLOW="\033[93m"
+RESET="\033[0m"
+BOLD="\033[1m"
+NORMAL="\033[22m"
+CHECK="\xE2\x9C\x94"
+
+PUSH=""
+REGISTRY=""
+REGISTRY_ORG=""
+IMAGE_PREFIX="ui-extension-"
+FORCE="false"
+GITHUB_BUILD="true"
+
+GITHUB_SOURCE=$(git config --get remote.origin.url | sed -e 's/^git@.*:\([[:graph:]]*\).git/\1/')
+GITHUB_BRANCH="main"
+
+usage() {
+  echo "Usage: $0 [<options>] [plugins]"
+  echo " options:"
+  echo "  -p           Push container images on build"
+  echo "  -f           Force building the chart even if it already exists"
+  echo "  -r <name>    Specify destination container registry for built images"
+  echo "  -o <name>    Specify destination container registry organization for built images"
+  echo "  -i <prefix>  Specify prefix for the built container image (default: 'ui-extension-')"
+  echo "  -c           Build as a container image rather than publishing to Github"
+  echo "  -s <repo>    Specify destination GitHub repository (org/name) - defaults to the git origin"
+  echo "  -b <branch>  Specify destination GitHub branch"
+  exit 1
+}
+
+while getopts "hvr:o:pi:fcb:s:" opt; do
+  case $opt in
+    h)
+      usage
+      ;;
+    p)
+      PUSH="--push"
+      ;;
+    r)
+      REGISTRY="${OPTARG%/}/"
+      ;;
+    o)
+      REGISTRY_ORG="${OPTARG}"
+      ;;
+    i)
+      IMAGE_PREFIX="${OPTARG}"
+      ;;
+    f)
+      FORCE="true"
+      ;;      
+    c)
+      GITHUB_BUILD="false"
+      ;;
+    s)
+      GITHUB_BUILD="true"
+      GITHUB_SOURCE="${OPTARG}"
+      ;;
+    b)
+      GITHUB_BUILD="true"
+      GITHUB_BRANCH="${OPTARG}"
+      ;;
+    *)
+      usage
+      ;;
+  esac
+done
+
+shift $((OPTIND-1))
+
+PLUGINS=( "$@" )
+BUILT="false"
+
+echo -e "${CYAN}${BOLD}Publishing UI Plugins${RESET}"
+
+pushd ${BASE_DIR} > /dev/null
+
+if [ "${GITHUB_BUILD}" == "true" ]; then
+  echo -e "${CYAN}GitHub Repository: ${GITHUB_SOURCE}${RESET}"
+  echo -e "${CYAN}GitHub Branch    : ${GITHUB_BRANCH}${RESET}"
+else
+  echo -e ${CYAN}"Image prefix: ${IMAGE_PREFIX}${RESET}"
+fi
+
+# --------------------------------------------------------------------------------
+# Check that we have the required commands avaialble for this script
+# --------------------------------------------------------------------------------
+
+if ! [[ -f ${BASE_DIR}/package.json ]]; then
+  echo -e "${YELLOW}You must run from the top-level folder${RESET}"
+  exit 1
+fi
+
+# Check this is a Rancher extension
+IS_SHELL=$(grep "\"@rancher/shell" package.json -c)
+
+if [ "${IS_SHELL}" -ne 1 ]; then
+  echo -e "${YELLOW}Current folder does not appear to contain Rancher Extensions${RESET}"
+  exit 1
+fi
+
+if ! [[ -d ${BASE_DIR}/node_modules ]]; then
+  echo -e "${YELLOW}You must run ${BOLD}yarn install${NORMAL} before running this script${RESET}"
+  exit 1
+fi
+
+COMMANDS=("node" "jq" "yq" "git" "docker" "helm" "yarn")
+HAVE_COMMANDS="true"
+for CMD in "${COMMANDS[@]}"
+do
+  if ! command -v ${CMD} >/dev/null; then
+    echo -e "${YELLOW}This script requires ${BOLD}${CMD}${NORMAL} to be installed and on your PATH${RESET}"
+    HAVE_COMMANDS="false"
+  fi
+done
+
+if [ "${HAVE_COMMANDS}" == "false" ]; then
+  exit 1
+fi
+
+# --------------------------------------------------------------------------------
+# Only do conatiner args checks if not GitHub publish
+if [ "${GITHUB_BUILD}" == "false" ]; then
+  if [[ -z ${REGISTRY_ORG} ]]; then
+    # Infer that the user has the same Docker registry org as their GitHub org
+    GITHUB_REPO=$(git config --get remote.origin.url | sed -e 's/^git@.*:\([[:graph:]]*\).git/\1/')
+    REGISTRY_ORG=$(dirname ${GITHUB_REPO})
+    echo -e "Inferring built images will reside in registry organization ${CYAN}${BOLD}${REGISTRY}${REGISTRY_ORG}${RESET} based on configured origin remote pointing to ${CYAN}${BOLD}${GITHUB_REPO}${RESET}"
+  fi
+
+  if [[ -z ${REGISTRY_ORG} ]]; then
+    # Inferring from the git config still failed
+    echo "Cannot build images without valid organization for Docker images. Unable to infer REGISTRY_ORG="
+    exit 1
+  fi
+
+  docker images > /dev/null
+  if [ $? -ne 0 ]; then
+    echo "docker is not running - this is required to build container images for the UI Plugins"
+    exit 1
+  fi
+fi
+
+ASSETS=${BASE_DIR}/assets
+CHARTS=${BASE_DIR}/charts
+mkdir -p ${ASSETS}
+mkdir -p ${CHARTS}
+
+TMP=${BASE_DIR}/tmp
+CHART_TMP=${BASE_DIR}/tmp/_charts
+rm -rf ${TMP}
+mkdir -p ${TMP}
+
+CHART_TEMPLATE=${BASE_DIR}/tmp/ui-plugin-server
+
+# --------------------------------------------------------------------------------
+# Clone the plugin server template into the temporary folder
+# --------------------------------------------------------------------------------
+pushd ${TMP} > /dev/null
+git clone -q https://github.com/nwmac/ui-plugin-server.git
+popd > /dev/null
+
+# --------------------------------------------------------------------------------
+# Iterate through all packages - built them all or build only those specified on the command line
+# --------------------------------------------------------------------------------
+for d in pkg/*/ ; do
+  pkg=$(basename $d)
+
+  if [ -z "$1" ] || [[ " ${PLUGINS[*]} " =~ " ${pkg} " ]]; then
+    # Check we don't already have a published version by looking in the assets folder
+    PKG_VERSION=$(jq -r .version ./pkg/${pkg}/package.json)
+    PKG_NAME="${pkg}-${PKG_VERSION}"
+    PKG_ASSET=${ASSETS}/${pkg}/${PKG_NAME}.tgz
+
+    echo -e "${CYAN}${BOLD}Building plugin: ${pkg} (${PKG_VERSION}) ${RESET}"
+
+    echo "Package version: ${PKG_VERSION}"
+    echo "Package folder:  ${PKG_NAME}"
+
+    # --------------------------------------------------------------------------------
+    # Build the plugin from source
+    # --------------------------------------------------------------------------------
+    echo -e "${CYAN}Building plugin from source code${RESET}"
+    FORCE_COLOR=1 yarn build-pkg $pkg | cat
+
+    if [ "${GITHUB_BUILD}" == "false" ]; then
+      # Build the docker image
+      ${SCRIPT_DIR}/bundle ${pkg} ${PKG_VERSION} ${REGISTRY} ${REGISTRY_ORG} ${IMAGE_PREFIX} ${PUSH}
+    else
+      echo -e "${CYAN}Adding plugin code ...${RESET}"
+
+      EXT_FOLDER=${BASE_DIR}/extensions/${pkg}/${PKG_VERSION}
+      PKG_DIST="${BASE_DIR}/dist-pkg/${PKG_NAME}"
+
+      rm -rf ${EXT_FOLDER}
+
+      mkdir -p ${EXT_FOLDER}/plugin
+
+      # Copy the code into the folder
+      cp -R ${PKG_DIST}/* ${EXT_FOLDER}/plugin
+
+      pushd ${BASE_DIR}/extensions/${pkg}/${PKG_VERSION} > /dev/null
+      rm -f plugin/report.html
+      find plugin -type f | sort > files.txt
+      popd > /dev/null
+    fi
+
+    rm -rf ${TMP}/container
+
+    # --------------------------------------------------------------------------------
+    # Create the Helm chart
+    # --------------------------------------------------------------------------------
+
+    if [ -f ${PKG_ASSET} ] && [ "${FORCE}" == "false" ]; then
+      echo -e "${YELLOW}Helm chart has already been created - skipping (run with -f to force build)${RESET}"
+      continue;
+    fi
+
+    CHART_FOLDER=${CHARTS}/${pkg}/${PKG_VERSION}
+
+    mkdir -p ${ASSETS}/${pkg}
+    rm -rf ${CHART_FOLDER}
+    mkdir -p ${CHART_FOLDER}
+
+    cp -R ${CHART_TEMPLATE}/charts/ui-plugin-server/* ${CHART_FOLDER}
+
+    # Update Chart.yaml and values.yaml from the package file metadata
+    # Use the script from the template repository
+    echo -e "${CYAN}Patching Helm chart template${RESET}"
+
+    CHART=${CHART_FOLDER} REGISTRY="${REGISTRY}" ORG="${REGISTRY_ORG}" PACKAGE_JSON=${BASE_DIR}/pkg/${pkg}/package.json ${CHART_TEMPLATE}/scripts/patch
+
+    # Copy README file from the plugin to the Helm chart, if there is one
+    if [ -f "./pkg/${pkg}/README.md" ]; then
+      cp ./pkg/${pkg}/README.md ${CHART_FOLDER}/README.md
+    fi
+
+    if [ "${GITHUB_BUILD}" == "true" ]; then
+      echo "Patching for GitHub build"
+      pushd ${CHART_FOLDER} > /dev/null
+      cd templates
+      mv cr.yaml temp.cr
+      rm *.yaml
+      mv temp.cr cr.yaml
+      ENDPOINT=https://raw.githubusercontent.com/${GITHUB_SOURCE}/${GITHUB_BRANCH}/extensions/${pkg}/${PKG_VERSION}
+      sed -i.bak -e 's@endpoint: .*@endpoint: '"${ENDPOINT}"'@g' cr.yaml       
+      rm *.bak
+      popd > /dev/null
+    fi
+
+    # Additional patches
+    ${SCRIPT_DIR}/helmpatch ${CHART_FOLDER} "${BASE_DIR}/pkg/${pkg}/package.json" "${REGISTRY}${REGISTRY_ORG}/${IMAGE_PREFIX}${pkg}"
+
+    # Package into a .tgz helm chart
+    helm package ${CHART_FOLDER} -d ${ASSETS}/${pkg}
+
+    # --------------------------------------------------------------------------------
+    # Update the helm index just for this chart 
+    # --------------------------------------------------------------------------------
+    HELM_INDEX=${BASE_DIR}/index.yaml
+
+    if [ -f "${HELM_INDEX}" ]; then
+      UPDATE="--merge ${HELM_INDEX}"
+    fi
+
+    # Base URL referencing assets directly from GitHub
+    BASE_URL="assets/${pkg}"
+
+    rm -rf ${CHART_TMP}
+    mkdir -p ${CHART_TMP}
+    cp ${ASSETS}/${pkg}/*.tgz ${CHART_TMP}
+
+    helm repo index ${CHART_TMP} --url ${BASE_URL} ${UPDATE}
+
+    cp ${CHART_TMP}/index.yaml ${HELM_INDEX}
+
+    if [ "${GITHUB_BUILD}" == "true" ]; then
+      # Make temp directory for workflow build artifact
+      mkdir -p tmp/{assets,charts,extensions}/$pkg
+
+      cp -r ${PKG_ASSET} tmp/assets/$pkg
+      cp -r ${CHARTS}/${pkg}/${PKG_VERSION} tmp/charts/$pkg
+      cp -r ${EXT_FOLDER} tmp/extensions/$pkg
+    fi
+
+    BUILT="true"
+  fi
+done
+
+if [ "${GITHUB_BUILD}" == "true" ]; then
+  cp index.yaml tmp
+fi
+
+if [ "${BUILT}" == "true" ]; then
+  echo -e "${CYAN}${BOLD}${CHECK} One or more packages built${RESET}"
+fi
+
+# Clean up
+rm -rf ${CHART_TMP}
+
+if [ "${GITHUB_BUILD}" == "false" ]; then
+  rm -rf ${TMP}
+fi
+
+# If the user asked to create a commit, commit the changes
+# if [ "${COMMIT}" == "true" ]; then
+#   echo -e "${CYAN}${BOLD}Creating git commit${RESET}"
+#   git add --all
+# fi

package/scripts/test-plugins-build.sh

@@ -91,6 +91,10 @@ ${SHELL_DIR}/scripts/publish-shell.sh
 yarn build:lib
 yarn publish:lib
 
+# We pipe into cat for cleaner logging - we need to set pipefail
+# to ensure the build fails in these cases
+set -o pipefail
+
 if [ "${SKIP_STANDALONE}" == "false" ]; then
   DIR=$(mktemp -d)
   pushd $DIR > /dev/null

package/store/__tests__/index.test.ts

@@ -0,0 +1,110 @@
+import { getters } from '../index';
+
+describe('getters', () => {
+  describe('namespaces', () => {
+    it('should return empty dictionary', () => {
+      const expectation = {};
+      const state = {};
+      const stateGetters = { currentProduct: () => ({}) };
+
+      const result = getters.namespaces(state, stateGetters)();
+
+      expect(result).toStrictEqual(expectation);
+    });
+
+    it('should return all the namespaces for related category', () => {
+      const clusterId = 'my-cluster';
+      const namespaceId = 'my-namespace';
+      const expectation = { [namespaceId]: true };
+      const state = {
+        allNamespaces:    [{ id: namespaceId }],
+        prefs:            { data: { 'all-namespaces': false } },
+        namespaceFilters: []
+      };
+      const stateGetters = {
+        isAllNamespaces: true,
+        currentProduct:  { inStore: 'whatever' },
+        'whatever/all':  {},
+        currentCluster:  { id: clusterId },
+      };
+
+      const result = getters.namespaces(state, stateGetters)();
+
+      expect(result).toStrictEqual(expectation);
+    });
+
+    it('should return Rancher system namespaces', () => {
+      const clusterId = 'my-cluster';
+      const namespaceId = 'my-rancher-system-namespace';
+      const expectation = { [namespaceId]: true };
+      const state = {
+        allNamespaces: [{
+          id:        namespaceId,
+          isObscure: true
+        }],
+        prefs:            { data: { 'all-namespaces': true } },
+        namespaceFilters: []
+      };
+      const stateGetters = {
+        isAllNamespaces: true,
+        currentProduct:  { inStore: 'whatever' },
+        'whatever/all':  {},
+        currentCluster:  { id: clusterId },
+      };
+
+      const result = getters.namespaces(state, stateGetters)();
+
+      expect(result).toStrictEqual(expectation);
+    });
+
+    it('should filter Rancher system namespaces', () => {
+      const clusterId = 'my-cluster';
+      const namespaceId = 'my-rancher-system-namespace';
+      const expectation = { };
+      const state = {
+        allNamespaces: [{
+          id:        namespaceId,
+          isObscure: true
+        }],
+        prefs:            { data: { 'all-namespaces': false } },
+        namespaceFilters: []
+      };
+      const stateGetters = {
+        isAllNamespaces: true,
+        currentProduct:  { inStore: 'whatever' },
+        'whatever/all':  {},
+        currentCluster:  { id: clusterId },
+      };
+
+      const result = getters.namespaces(state, stateGetters)();
+
+      expect(result).toStrictEqual(expectation);
+    });
+
+    it('should filter namespaces by project', () => {
+      const clusterId = 'my-cluster';
+      const namespaceId = 'my-product-namespace';
+      const projectId = 'my-project';
+      const expectation = { [namespaceId]: true };
+      const state = {
+        allNamespaces:    [{ id: namespaceId }],
+        prefs:            { data: { 'all-namespaces': false } },
+        namespaceFilters: [`project://${ projectId }`]
+      };
+      const stateGetters = {
+        isAllNamespaces:   false,
+        currentProduct:    { inStore: 'whatever' },
+        'whatever/all':    {},
+        'management/byId': () => ({
+          id:         projectId,
+          namespaces: [{ id: namespaceId }]
+        }),
+        currentCluster: { id: clusterId },
+      };
+
+      const result = getters.namespaces(state, stateGetters)();
+
+      expect(result).toStrictEqual(expectation);
+    });
+  });
+});