[wip] [5 of #107] add dynamic options (#125)

* adopt dynamic options pattern, with temporary condaConfig * collapse additional type imports
conda-incubator · Dec 20, 2020 · 9ed7b04 · 9ed7b04
1 parent 21dbde1
commit 9ed7b04
Show file tree

Hide file tree

Showing 11 changed files with 276 additions and 231 deletions.
diff --git a/dist/setup/index.js b/dist/setup/index.js
diff --git a/src/conda.ts b/src/conda.ts
@@ -10,15 +10,15 @@ import * as core from "@actions/core";
 import * as io from "@actions/io";
 
 import { IS_LINUX, IS_MAC, IS_WINDOWS, MINICONDA_DIR_PATH } from "./constants";
-import { IShells, TCondaConfig } from "./types";
 import { execute } from "./utils";
+import * as types from "./types";
 
 /**
  * Provide current location of miniconda or location where it will be installed
  */
-export function minicondaPath(useBundled: boolean = true): string {
+export function minicondaPath(options: types.IDynamicOptions): string {
   let condaPath: string = MINICONDA_DIR_PATH;
-  if (!useBundled) {
+  if (!options.useBundled) {
     if (IS_MAC) {
       condaPath = "/Users/runner/miniconda3";
     } else {
@@ -31,14 +31,11 @@ export function minicondaPath(useBundled: boolean = true): string {
 /**
  * Provide cross platform location of conda/mamba executable
  */
-export function condaExecutable(
-  useBundled: boolean,
-  useMamba: boolean = false
-): string {
-  const dir: string = minicondaPath(useBundled);
+export function condaExecutable(options: types.IDynamicOptions): string {
+  const dir: string = minicondaPath(options);
   let condaExe: string;
   let commandName: string;
-  commandName = useMamba ? "mamba" : "conda";
+  commandName = options.useMamba ? "mamba" : "conda";
   commandName = IS_WINDOWS ? commandName + ".bat" : commandName;
   condaExe = path.join(dir, "condabin", commandName);
   return condaExe;
@@ -49,41 +46,42 @@ export function condaExecutable(
  */
 export async function condaCommand(
   cmd: string[],
-  useBundled: boolean,
-  useMamba: boolean = false
+  options: types.IDynamicOptions
 ): Promise<void> {
-  const command = [condaExecutable(useBundled, useMamba), ...cmd];
+  const command = [condaExecutable(options), ...cmd];
   return await execute(command);
 }
 
 /**
  * Setup Conda configuration
  */
 export async function applyCondaConfiguration(
-  condaConfig: TCondaConfig,
-  useBundled: boolean
+  options: types.IDynamicOptions
 ): Promise<void> {
-  for (const key of Object.keys(condaConfig)) {
-    core.info(`"${key}": "${condaConfig[key]}"`);
-    if (condaConfig[key].length !== 0) {
+  // TODO: figure out a way to know a-priori if we have mamba for initial commands
+  const notMambaOptions = { ...options, useMamba: false };
+
+  for (const key of Object.keys(options.condaConfig)) {
+    core.info(`"${key}": "${options.condaConfig[key]}"`);
+    if (options.condaConfig[key].length !== 0) {
       if (key === "channels") {
         // Split by comma and reverse order to preserve higher priority
         // as listed in the option
-        let channels: Array<string> = condaConfig[key].split(",").reverse();
+        let channels: Array<string> = options.condaConfig[key]
+          .split(",")
+          .reverse();
         let channel: string;
         for (channel of channels) {
           await condaCommand(
             ["config", "--add", key, channel],
-            useBundled,
-            false
+            notMambaOptions
           );
         }
       } else {
         try {
           await condaCommand(
-            ["config", "--set", key, condaConfig[key]],
-            useBundled,
-            false
+            ["config", "--set", key, options.condaConfig[key]],
+            options
           );
         } catch (err) {
           core.warning(`Couldn't set conda configuration '${key}'`);
@@ -92,30 +90,28 @@ export async function applyCondaConfiguration(
     }
   }
 
-  await condaCommand(["config", "--show-sources"], useBundled, false);
+  await condaCommand(["config", "--show-sources"], notMambaOptions);
 
-  await condaCommand(["config", "--show"], useBundled, false);
+  await condaCommand(["config", "--show"], notMambaOptions);
 }
 
 /**
  * Initialize Conda
  */
 export async function condaInit(
-  activateEnvironment: string,
-  useBundled: boolean,
-  condaConfig: TCondaConfig,
-  removeProfiles: string
+  inputs: types.IActionInputs,
+  options: types.IDynamicOptions
 ): Promise<void> {
   let ownPath: string;
   const isValidActivate: boolean =
-    activateEnvironment !== "base" &&
-    activateEnvironment !== "root" &&
-    activateEnvironment !== "";
+    inputs.activateEnvironment !== "base" &&
+    inputs.activateEnvironment !== "root" &&
+    inputs.activateEnvironment !== "";
   const autoActivateBase: boolean =
-    condaConfig["auto_activate_base"] === "true";
+    options.condaConfig["auto_activate_base"] === "true";
 
   // Fix ownership of folders
-  if (useBundled) {
+  if (options.useBundled) {
     if (IS_MAC) {
       core.startGroup("Fixing conda folders ownership");
       const userName: string = process.env.USER as string;
@@ -124,7 +120,7 @@ export async function condaInit(
         "chown",
         "-R",
         `${userName}:staff`,
-        minicondaPath(useBundled),
+        minicondaPath(options),
       ]);
       core.endGroup();
     } else if (IS_WINDOWS) {
@@ -135,7 +131,7 @@ export async function condaInit(
         "etc/profile.d/",
         "/Lib/site-packages/xonsh/",
       ]) {
-        ownPath = path.join(minicondaPath(useBundled), folder);
+        ownPath = path.join(minicondaPath(options), folder);
         if (fs.existsSync(ownPath)) {
           core.startGroup(`Fixing ${folder} ownership`);
           await execute(["takeown", "/f", ownPath, "/r", "/d", "y"]);
@@ -146,7 +142,7 @@ export async function condaInit(
   }
 
   // Remove profile files
-  if (removeProfiles == "true") {
+  if (inputs.removeProfiles == "true") {
     for (let rc of [
       ".bashrc",
       ".bash_profile",
@@ -173,7 +169,12 @@ export async function condaInit(
 
   // Run conda init
   for (let cmd of ["--all"]) {
-    await execute([condaExecutable(useBundled, false), "init", cmd]);
+    // TODO: determine when it's safe to use mamba
+    await execute([
+      condaExecutable({ ...options, useMamba: false }),
+      "init",
+      cmd,
+    ]);
   }
 
   // Rename files
@@ -195,7 +196,7 @@ export async function condaInit(
   if (isValidActivate) {
     powerExtraText += `
   # Conda Setup Action: Custom activation
-  conda activate ${activateEnvironment}`;
+  conda activate ${inputs.activateEnvironment}`;
   }
   powerExtraText += `
   # ----------------------------------------------------------------------------`;
@@ -208,7 +209,7 @@ export async function condaInit(
   if (isValidActivate) {
     bashExtraText += `
   # Conda Setup Action: Custom activation
-  conda activate ${activateEnvironment}`;
+  conda activate ${inputs.activateEnvironment}`;
     bashExtraText += `
   # ----------------------------------------------------------------------------`;
   }
@@ -224,16 +225,16 @@ export async function condaInit(
   if (isValidActivate) {
     batchExtraText += `
   :: Conda Setup Action: Custom activation
-  @CALL "%CONDA_BAT%" activate ${activateEnvironment}`;
+  @CALL "%CONDA_BAT%" activate ${inputs.activateEnvironment}`;
   }
   batchExtraText += `
   :: Conda Setup Action: Basic configuration
   @SETLOCAL EnableExtensions
   @SETLOCAL DisableDelayedExpansion
   :: ---------------------------------------------------------------------------`;
 
-  let extraShells: IShells;
-  const shells: IShells = {
+  let extraShells: types.IShells;
+  const shells: types.IShells = {
     "~/.bash_profile": bashExtraText,
     "~/.profile": bashExtraText,
     "~/.zshrc": bashExtraText,
@@ -244,7 +245,7 @@ export async function condaInit(
     "~/Documents/PowerShell/profile.ps1": powerExtraText,
     "~/Documents/WindowsPowerShell/profile.ps1": powerExtraText,
   };
-  if (useBundled) {
+  if (options.useBundled) {
     extraShells = {
       "C:/Miniconda/etc/profile.d/conda.sh": bashExtraText,
       "C:/Miniconda/etc/fish/conf.d/conda.fish": bashExtraText,
@@ -257,7 +258,7 @@ export async function condaInit(
       "C:/Miniconda3/condabin/conda_hook.bat": batchExtraText,
     };
   }
-  const allShells: IShells = { ...shells, ...extraShells };
+  const allShells: types.IShells = { ...shells, ...extraShells };
   Object.keys(allShells).forEach((key) => {
     let filePath: string = key.replace("~", os.homedir());
     const text = allShells[key];

diff --git a/src/constants.ts b/src/constants.ts
@@ -1,7 +1,7 @@
 import * as os from "os";
 import * as path from "path";
 
-import { IArchitectures, IOperatingSystems } from "./types";
+import * as types from "./types";
 
 //-----------------------------------------------------------------------
 // Constants
@@ -14,14 +14,14 @@ export const IS_UNIX: boolean = IS_MAC || IS_LINUX;
 export const MINICONDA_BASE_URL: string =
   "https://repo.anaconda.com/miniconda/";
 
-export const ARCHITECTURES: IArchitectures = {
+export const ARCHITECTURES: types.IArchitectures = {
   x64: "x86_64",
   x86: "x86",
   ARM64: "aarch64", // To be supported by github runners
   ARM32: "armv7l", // To be supported by github runners
 };
 
-export const OS_NAMES: IOperatingSystems = {
+export const OS_NAMES: types.IOperatingSystems = {
   win32: "Windows",
   darwin: "MacOSX",
   linux: "Linux",

diff --git a/src/env.ts b/src/env.ts
@@ -4,15 +4,19 @@ import * as path from "path";
 import * as core from "@actions/core";
 
 import { minicondaPath, condaCommand } from "./conda";
+import * as types from "./types";
 
 /**
  * Check if a given conda environment exists
  */
-export function environmentExists(name: string, useBundled: boolean): boolean {
+export function environmentExists(
+  inputs: types.IActionInputs,
+  options: types.IDynamicOptions
+): boolean {
   const condaMetaPath: string = path.join(
-    minicondaPath(useBundled),
+    minicondaPath(options),
     "envs",
-    name,
+    inputs.activateEnvironment,
     "conda-meta"
   );
   return fs.existsSync(condaMetaPath);
@@ -22,21 +26,19 @@ export function environmentExists(name: string, useBundled: boolean): boolean {
  * Create test environment
  */
 export async function createTestEnvironment(
-  activateEnvironment: string,
-  useBundled: boolean,
-  useMamba: boolean
+  inputs: types.IActionInputs,
+  options: types.IDynamicOptions
 ): Promise<void> {
   if (
-    activateEnvironment !== "root" &&
-    activateEnvironment !== "base" &&
-    activateEnvironment !== ""
+    inputs.activateEnvironment !== "root" &&
+    inputs.activateEnvironment !== "base" &&
+    inputs.activateEnvironment !== ""
   ) {
-    if (!environmentExists(activateEnvironment, useBundled)) {
+    if (!environmentExists(inputs, options)) {
       core.startGroup("Create test environment...");
       await condaCommand(
-        ["create", "--name", activateEnvironment],
-        useBundled,
-        useMamba
+        ["create", "--name", inputs.activateEnvironment],
+        options
       );
       core.endGroup();
     }

diff --git a/src/installer/base.ts b/src/installer/base.ts
@@ -6,9 +6,9 @@ import * as core from "@actions/core";
 import * as io from "@actions/io";
 import * as tc from "@actions/tool-cache";
 
-import { ILocalInstallerOpts } from "../types";
 import { minicondaPath } from "../conda";
 import { execute } from "../utils";
+import * as types from "../types";
 
 /** Get the path for a locally-executable installer from cache, or as downloaded
  *
@@ -22,7 +22,7 @@ import { execute } from "../utils";
  * - or has been renamed during a build process
  */
 export async function ensureLocalInstaller(
-  options: ILocalInstallerOpts
+  options: types.ILocalInstallerOpts
 ): Promise<string> {
   core.startGroup("Ensuring Installer...");
 
@@ -88,9 +88,9 @@ export async function ensureLocalInstaller(
  */
 export async function runInstaller(
   installerPath: string,
-  useBundled: boolean
+  options: types.IDynamicOptions
 ): Promise<void> {
-  const outputPath: string = minicondaPath(useBundled);
+  const outputPath: string = minicondaPath(options);
   const installerExtension = path.extname(installerPath);
   let command: string[];
 

diff --git a/src/installer/download-miniconda.ts b/src/installer/download-miniconda.ts
@@ -13,6 +13,8 @@ import {
   OS_NAMES,
 } from "../constants";
 
+import * as types from "../types";
+
 /**
  * List available Miniconda versions
  *
@@ -45,18 +47,17 @@ async function minicondaVersions(arch: string): Promise<string[]> {
  */
 export async function downloadMiniconda(
   pythonMajorVersion: number,
-  minicondaVersion: string,
-  architecture: string
+  inputs: types.IActionInputs
 ): Promise<string> {
   // Check valid arch
-  const arch: string = ARCHITECTURES[architecture];
+  const arch: string = ARCHITECTURES[inputs.architecture];
   if (!arch) {
-    throw new Error(`Invalid arch "${architecture}"!`);
+    throw new Error(`Invalid arch "${inputs.architecture}"!`);
   }
 
   let extension: string = IS_UNIX ? "sh" : "exe";
   let osName: string = OS_NAMES[process.platform];
-  const minicondaInstallerName: string = `Miniconda${pythonMajorVersion}-${minicondaVersion}-${osName}-${arch}.${extension}`;
+  const minicondaInstallerName: string = `Miniconda${pythonMajorVersion}-${inputs.minicondaVersion}-${osName}-${arch}.${extension}`;
   core.info(minicondaInstallerName);
 
   // Check version name
@@ -72,7 +73,7 @@ export async function downloadMiniconda(
   return await ensureLocalInstaller({
     url: MINICONDA_BASE_URL + minicondaInstallerName,
     tool: `Miniconda${pythonMajorVersion}`,
-    version: minicondaVersion,
+    version: inputs.minicondaVersion,
     arch: arch,
   });
 }
diff --git a/src/installer/download-url.ts b/src/installer/download-url.ts
@@ -1,8 +1,11 @@
 import { ensureLocalInstaller } from "./base";
+import * as types from "../types";
 
 /**
  * @param url A URL for a file with the CLI of a `constructor`-built artifact
  */
-export async function downloadCustomInstaller(url: string): Promise<string> {
-  return await ensureLocalInstaller({ url });
+export async function downloadCustomInstaller(
+  inputs: types.IActionInputs
+): Promise<string> {
+  return await ensureLocalInstaller({ url: inputs.installerUrl });
 }