1
0
Fork 0
mirror of https://github.com/actions/setup-java synced 2024-12-23 05:34:56 +00:00

Add inputs 'update-toolchains-only', 'update-env-javahome', 'add-to-env-path'

Changes in detail:
------------------
- action.yml:
  - add inputs:
    - update-toolchains-only
    - update-env-javahome
    - add-to-env-path
  - update description for input "overwrite-settings"
  - remove default value of input "overwrite-settings",
    since the default is now propagated from input 'update-toolchains-only'

- base-models.ts:
  - extend interface JavaInstallerOptions:
    - add fields:
      - updateEnvJavaHome: boolean;
      - addToEnvPath: boolean;

- constants.ts:
  - add constant INPUT_UPDATE_TOOLCHAINS_ONLY
    = 'update-toolchains-only'

- auth.ts:
  - function configureAuthentication():
    - add parameter:
      - overwriteSettings: boolean
    - remove the now obsolete const overwriteSettings

- toolchains.ts:
  - function configureToolchains(...):
    - add parameter updateToolchains: boolean
    - remove the now obsolete const overwriteSettings
  - improve variable naming:
    - rename any occurrence of 'overwriteSettings'
        by 'updateToolchains'
    - add field updateToolchains: boolean to the parameter object
  - function writeToolchainsFileToDisk(...):
    - improve variable naming:
      - rename variable 'settingsExists'
          by 'toolchainsExists'
    - update wording of info logs to be more applicable

- setup-java.ts:
  - interface installerInputsOptions:
    - rename to IInstallerInputsOption to meet common coding convention
    - add fields:
      - updateToolchainsOnly: boolean;
      - overwriteSettings: boolean;
      - updateEnvJavaHome: boolean;
      - addToEnvPath: boolean;
  - function run():
    - add const:
      - const updateToolchainsOnly:
        - get as boolean from input 'update-toolchains-only', default: false
      - const overwriteSettings:
        - get as boolean from input 'overwrite-settings', default: !updateToolchainsOnly
      - const updateEnvJavaHome:
        - get as boolean input 'update-env-javahome', default: !updateToolchainsOnly
      - const addToEnvPath:
        - get as boolean input 'add-to-env-path', default: !updateToolchainsOnly
   - extend const installerInputsOptions to match with IInstallerInputsOption:
      - add field updateToolchainsOnly
      - add field overwriteSettings
      - add field updateEnvJavaHome
      - add field addToEnvPath
    - update call of auth.configureAuthentication()
        to auth.configureAuthentication(overwriteSettings)
  - function installVersion(...):
    - add const and init from parameter options:
      - updateToolchainsOnly, overwriteSettings,
        updateEnvJavaHome, addToEnvPath
    - init the additional fields of installerInputsOptions accordingly
    - call toolchains.configureToolchains(...):
      - with parameter updateToolchains= overwriteSettings || updateToolchainsOnly

- base-installer.ts:
  - add constants to import from constants:
    - INPUT_UPDATE_JAVA_HOME
    - INPUT_ADD_TO_PATH
  - add fields:
    - protected updateEnvJavaHome: boolean;
    - protected addToEnvPath: boolean;
  - ctor:
    - init these fields from JavaInstallerOptions accoprdingly
  - function setJavaDefault(...):
    - if updateEnvJavaHome is false:
      - SKIP updating env.JAVA_HOME
      - log info:
        `Skip updating env.JAVA_HOME according to ${INPUT_UPDATE_JAVA_HOME}`
    - if addToEnvPath is false:
      - SKIP adding toolchain path to env.PATH
      - log info:
        `Skip adding to env.PATH according to ${INPUT_ADD_TO_PATH}`
This commit is contained in:
Markus Hoffrogge 2023-11-07 00:27:36 +01:00 committed by Markus Hoffrogge
parent 7a6d8a8234
commit 45f1a8d74b
7 changed files with 89 additions and 41 deletions

View file

@ -43,9 +43,21 @@ inputs:
description: 'Path to where the settings.xml file will be written. Default is ~/.m2.' description: 'Path to where the settings.xml file will be written. Default is ~/.m2.'
required: false required: false
overwrite-settings: overwrite-settings:
description: 'Overwrite the settings.xml file if it exists. Default is "true".' description: 'Overwrite the settings.xml file if it exists. Default is "!update-toolchains-only". If explcitly set "true", it will update settings.xml regardless of "update-toolchains-only"'
required: false required: false
default: true # DO NOT set a default here! The default will be propagated from input 'update-toolchains-only'!
update-toolchains-only:
description: 'Update toolchains.xml only. Default is "false". No update of settings.xml, no update of JAVA_HOME, no adding to PATH by default - unless "overwrite-settings", "update-env-javahome" or "add-to-env-path" are not explicitly set "true"'
required: false
default: false
update-env-javahome:
description: 'Update the JAVA_HOME environment variable. Default is "!update-toolchains-only"'
required: false
# DO NOT set a default here! The default will be propagated from input 'update-toolchains-only'!
add-to-env-path:
description: 'Add "<JDK home>/bin" to the PATH environment variable. Default is "!update-toolchains-only"'
required: false
# DO NOT set a default here! The default will be propagated from input 'update-toolchains-only'!
gpg-private-key: gpg-private-key:
description: 'GPG private key to import. Default is empty string.' description: 'GPG private key to import. Default is empty string.'
required: false required: false

View file

@ -10,17 +10,15 @@ import * as constants from './constants';
import * as gpg from './gpg'; import * as gpg from './gpg';
import {getBooleanInput} from './util'; import {getBooleanInput} from './util';
export async function configureAuthentication() { export async function configureAuthentication(
overwriteSettings: boolean
) {
const id = core.getInput(constants.INPUT_SERVER_ID); const id = core.getInput(constants.INPUT_SERVER_ID);
const username = core.getInput(constants.INPUT_SERVER_USERNAME); const username = core.getInput(constants.INPUT_SERVER_USERNAME);
const password = core.getInput(constants.INPUT_SERVER_PASSWORD); const password = core.getInput(constants.INPUT_SERVER_PASSWORD);
const settingsDirectory = const settingsDirectory =
core.getInput(constants.INPUT_SETTINGS_PATH) || core.getInput(constants.INPUT_SETTINGS_PATH) ||
path.join(os.homedir(), constants.M2_DIR); path.join(os.homedir(), constants.M2_DIR);
const overwriteSettings = getBooleanInput(
constants.INPUT_OVERWRITE_SETTINGS,
true
);
const gpgPrivateKey = const gpgPrivateKey =
core.getInput(constants.INPUT_GPG_PRIVATE_KEY) || core.getInput(constants.INPUT_GPG_PRIVATE_KEY) ||
constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; constants.INPUT_DEFAULT_GPG_PRIVATE_KEY;

View file

@ -11,6 +11,9 @@ export const INPUT_SERVER_USERNAME = 'server-username';
export const INPUT_SERVER_PASSWORD = 'server-password'; export const INPUT_SERVER_PASSWORD = 'server-password';
export const INPUT_SETTINGS_PATH = 'settings-path'; export const INPUT_SETTINGS_PATH = 'settings-path';
export const INPUT_OVERWRITE_SETTINGS = 'overwrite-settings'; export const INPUT_OVERWRITE_SETTINGS = 'overwrite-settings';
export const INPUT_UPDATE_TOOLCHAINS_ONLY = 'update-toolchains-only';
export const INPUT_UPDATE_JAVA_HOME = 'update-env-javahome';
export const INPUT_ADD_TO_PATH = 'add-to-env-path';
export const INPUT_GPG_PRIVATE_KEY = 'gpg-private-key'; export const INPUT_GPG_PRIVATE_KEY = 'gpg-private-key';
export const INPUT_GPG_PASSPHRASE = 'gpg-passphrase'; export const INPUT_GPG_PASSPHRASE = 'gpg-passphrase';

View file

@ -10,7 +10,11 @@ import {
JavaInstallerOptions, JavaInstallerOptions,
JavaInstallerResults JavaInstallerResults
} from './base-models'; } from './base-models';
import {MACOS_JAVA_CONTENT_POSTFIX} from '../constants'; import {
MACOS_JAVA_CONTENT_POSTFIX,
INPUT_UPDATE_JAVA_HOME,
INPUT_ADD_TO_PATH
} from '../constants';
import os from 'os'; import os from 'os';
export abstract class JavaBase { export abstract class JavaBase {
@ -20,6 +24,8 @@ export abstract class JavaBase {
protected packageType: string; protected packageType: string;
protected stable: boolean; protected stable: boolean;
protected checkLatest: boolean; protected checkLatest: boolean;
protected updateEnvJavaHome: boolean;
protected addToEnvPath: boolean;
constructor( constructor(
protected distribution: string, protected distribution: string,
@ -36,6 +42,8 @@ export abstract class JavaBase {
this.architecture = installerOptions.architecture || os.arch(); this.architecture = installerOptions.architecture || os.arch();
this.packageType = installerOptions.packageType; this.packageType = installerOptions.packageType;
this.checkLatest = installerOptions.checkLatest; this.checkLatest = installerOptions.checkLatest;
this.updateEnvJavaHome = installerOptions.updateEnvJavaHome;
this.addToEnvPath = installerOptions.addToEnvPath;
} }
protected abstract downloadTool( protected abstract downloadTool(
@ -163,8 +171,16 @@ export abstract class JavaBase {
protected setJavaDefault(version: string, toolPath: string) { protected setJavaDefault(version: string, toolPath: string) {
const majorVersion = version.split('.')[0]; const majorVersion = version.split('.')[0];
if (this.updateEnvJavaHome) {
core.exportVariable('JAVA_HOME', toolPath); core.exportVariable('JAVA_HOME', toolPath);
} else {
core.info(`Skip updating env.JAVA_HOME according to ${INPUT_UPDATE_JAVA_HOME}`);
}
if (this.addToEnvPath) {
core.addPath(path.join(toolPath, 'bin')); core.addPath(path.join(toolPath, 'bin'));
} else {
core.info(`Skip adding to env.PATH according to ${INPUT_ADD_TO_PATH}`);
}
core.setOutput('distribution', this.distribution); core.setOutput('distribution', this.distribution);
core.setOutput('path', toolPath); core.setOutput('path', toolPath);
core.setOutput('version', version); core.setOutput('version', version);

View file

@ -3,6 +3,8 @@ export interface JavaInstallerOptions {
architecture: string; architecture: string;
packageType: string; packageType: string;
checkLatest: boolean; checkLatest: boolean;
updateEnvJavaHome: boolean;
addToEnvPath: boolean;
} }
export interface JavaInstallerResults { export interface JavaInstallerResults {

View file

@ -13,6 +13,19 @@ import * as path from 'path';
import {getJavaDistribution} from './distributions/distribution-factory'; import {getJavaDistribution} from './distributions/distribution-factory';
import {JavaInstallerOptions} from './distributions/base-models'; import {JavaInstallerOptions} from './distributions/base-models';
interface IInstallerInputsOptions {
architecture: string;
packageType: string;
checkLatest: boolean;
distributionName: string;
jdkFile: string;
toolchainIds: Array<string>;
updateToolchainsOnly: boolean;
overwriteSettings: boolean;
updateEnvJavaHome: boolean;
addToEnvPath: boolean;
}
async function run() { async function run() {
try { try {
const versions = core.getMultilineInput(constants.INPUT_JAVA_VERSION); const versions = core.getMultilineInput(constants.INPUT_JAVA_VERSION);
@ -28,6 +41,11 @@ async function run() {
constants.INPUT_CACHE_DEPENDENCY_PATH constants.INPUT_CACHE_DEPENDENCY_PATH
); );
const checkLatest = getBooleanInput(constants.INPUT_CHECK_LATEST, false); const checkLatest = getBooleanInput(constants.INPUT_CHECK_LATEST, false);
const updateToolchainsOnly = getBooleanInput(constants.INPUT_UPDATE_TOOLCHAINS_ONLY, false);
const overwriteSettings = getBooleanInput(constants.INPUT_OVERWRITE_SETTINGS, !updateToolchainsOnly);
const updateEnvJavaHome = getBooleanInput(constants.INPUT_UPDATE_JAVA_HOME, !updateToolchainsOnly);
const addToEnvPath = getBooleanInput(constants.INPUT_ADD_TO_PATH, !updateToolchainsOnly);
let toolchainIds = core.getMultilineInput(constants.INPUT_MVN_TOOLCHAIN_ID); let toolchainIds = core.getMultilineInput(constants.INPUT_MVN_TOOLCHAIN_ID);
core.startGroup('Installed distributions'); core.startGroup('Installed distributions');
@ -40,13 +58,17 @@ async function run() {
throw new Error('java-version or java-version-file input expected'); throw new Error('java-version or java-version-file input expected');
} }
const installerInputsOptions: installerInputsOptions = { const installerInputsOptions: IInstallerInputsOptions = {
architecture, architecture,
packageType, packageType,
checkLatest, checkLatest,
distributionName, distributionName,
jdkFile, jdkFile,
toolchainIds toolchainIds,
updateToolchainsOnly,
overwriteSettings,
updateEnvJavaHome,
addToEnvPath
}; };
if (!versions.length) { if (!versions.length) {
@ -78,7 +100,7 @@ async function run() {
const matchersPath = path.join(__dirname, '..', '..', '.github'); const matchersPath = path.join(__dirname, '..', '..', '.github');
core.info(`##[add-matcher]${path.join(matchersPath, 'java.json')}`); core.info(`##[add-matcher]${path.join(matchersPath, 'java.json')}`);
await auth.configureAuthentication(); await auth.configureAuthentication(overwriteSettings);
if (cache && isCacheFeatureAvailable()) { if (cache && isCacheFeatureAvailable()) {
await restore(cache, cacheDependencyPath); await restore(cache, cacheDependencyPath);
} }
@ -91,7 +113,7 @@ run();
async function installVersion( async function installVersion(
version: string, version: string,
options: installerInputsOptions, options: IInstallerInputsOptions,
toolchainId = 0 toolchainId = 0
) { ) {
const { const {
@ -100,14 +122,20 @@ async function installVersion(
architecture, architecture,
packageType, packageType,
checkLatest, checkLatest,
toolchainIds toolchainIds,
updateToolchainsOnly,
overwriteSettings,
updateEnvJavaHome,
addToEnvPath
} = options; } = options;
const installerOptions: JavaInstallerOptions = { const installerOptions: JavaInstallerOptions = {
version,
architecture, architecture,
packageType, packageType,
checkLatest, checkLatest,
version updateEnvJavaHome,
addToEnvPath
}; };
const distribution = getJavaDistribution( const distribution = getJavaDistribution(
@ -126,6 +154,7 @@ async function installVersion(
version, version,
distributionName, distributionName,
result.path, result.path,
overwriteSettings || updateToolchainsOnly,
toolchainIds[toolchainId] toolchainIds[toolchainId]
); );
@ -136,12 +165,3 @@ async function installVersion(
core.info(` Path: ${result.path}`); core.info(` Path: ${result.path}`);
core.info(''); core.info('');
} }
interface installerInputsOptions {
architecture: string;
packageType: string;
checkLatest: boolean;
distributionName: string;
jdkFile: string;
toolchainIds: Array<string>;
}

View file

@ -19,6 +19,7 @@ export async function configureToolchains(
version: string, version: string,
distributionName: string, distributionName: string,
jdkHome: string, jdkHome: string,
updateToolchains: boolean,
toolchainId?: string toolchainId?: string
) { ) {
const vendor = const vendor =
@ -27,10 +28,6 @@ export async function configureToolchains(
const settingsDirectory = const settingsDirectory =
core.getInput(constants.INPUT_SETTINGS_PATH) || core.getInput(constants.INPUT_SETTINGS_PATH) ||
path.join(os.homedir(), constants.M2_DIR); path.join(os.homedir(), constants.M2_DIR);
const overwriteSettings = getBooleanInput(
constants.INPUT_OVERWRITE_SETTINGS,
true
);
await createToolchainsSettings({ await createToolchainsSettings({
jdkInfo: { jdkInfo: {
@ -40,21 +37,21 @@ export async function configureToolchains(
jdkHome jdkHome
}, },
settingsDirectory, settingsDirectory,
overwriteSettings updateToolchains
}); });
} }
export async function createToolchainsSettings({ export async function createToolchainsSettings({
jdkInfo, jdkInfo,
settingsDirectory, settingsDirectory,
overwriteSettings updateToolchains
}: { }: {
jdkInfo: JdkInfo; jdkInfo: JdkInfo;
settingsDirectory: string; settingsDirectory: string;
overwriteSettings: boolean; updateToolchains: boolean;
}) { }) {
core.info( core.info(
`Creating ${constants.MVN_TOOLCHAINS_FILE} for JDK version ${jdkInfo.version} from ${jdkInfo.vendor}` `Adding a toolchain entry in ${constants.MVN_TOOLCHAINS_FILE} for JDK version ${jdkInfo.version} from ${jdkInfo.vendor}`
); );
// when an alternate m2 location is specified use only that location (no .m2 directory) // when an alternate m2 location is specified use only that location (no .m2 directory)
// otherwise use the home/.m2/ path // otherwise use the home/.m2/ path
@ -72,7 +69,7 @@ export async function createToolchainsSettings({
await writeToolchainsFileToDisk( await writeToolchainsFileToDisk(
settingsDirectory, settingsDirectory,
updatedToolchains, updatedToolchains,
overwriteSettings updateToolchains
); );
} }
@ -147,17 +144,17 @@ async function readExistingToolchainsFile(directory: string) {
async function writeToolchainsFileToDisk( async function writeToolchainsFileToDisk(
directory: string, directory: string,
settings: string, settings: string,
overwriteSettings: boolean updateToolchains: boolean
) { ) {
const location = path.join(directory, constants.MVN_TOOLCHAINS_FILE); const location = path.join(directory, constants.MVN_TOOLCHAINS_FILE);
const settingsExists = fs.existsSync(location); const toolchainsExists = fs.existsSync(location);
if (settingsExists && overwriteSettings) { if (toolchainsExists && updateToolchains) {
core.info(`Overwriting existing file ${location}`); core.info(`Updating existing file ${location}`);
} else if (!settingsExists) { } else if (!toolchainsExists) {
core.info(`Writing to ${location}`); core.info(`Creating file ${location}`);
} else { } else {
core.info( core.info(
`Skipping generation of ${location} because file already exists and overwriting is not enabled` `Skipping update of ${location} since file already exists and updating is not enabled`
); );
return; return;
} }