in client/src/components/runs/actions/run.js [261:569]
function runFn (
payload,
confirm,
title,
warning,
stores,
callbackFn,
allowedInstanceTypesRequest,
hostedApplicationConfiguration,
platform,
skipCheck
) {
return new Promise(async (resolve) => {
let launchName;
let launchVersion;
let availableInstanceTypes = [];
let availablePriceTypes = [true, false];
const {
dataStorageAvailable,
authenticatedUserInfo
} = stores;
allowedInstanceTypesRequest && await allowedInstanceTypesRequest.fetchIfNeededOrWait();
if (allowedInstanceTypesRequest && allowedInstanceTypesRequest.loaded) {
if (payload.dockerImage) {
availableInstanceTypes = (
allowedInstanceTypesRequest.value[names.allowedToolInstanceTypes] || []
).map(i => i);
} else {
availableInstanceTypes = (
allowedInstanceTypesRequest.value[names.allowedInstanceTypes] || []
).map(i => i);
}
availablePriceTypes = (
allowedInstanceTypesRequest.value[names.allowedPriceTypes] || []
).map(p => {
if (p === 'spot') {
return true;
} else if (p === 'on_demand') {
return false;
}
return undefined;
}).filter(p => p !== undefined);
} else if (stores && (stores.spotInstanceTypes || stores.onDemandInstanceTypes)) {
let storeName = 'onDemandInstanceTypes';
if (payload.isSpot) {
storeName = 'spotInstanceTypes';
}
await stores[storeName].fetchIfNeededOrWait();
if (stores[storeName].loaded) {
availableInstanceTypes = (stores[storeName].value || []).map(i => i);
}
}
if (stores.preferences) {
await stores.preferences.fetchIfNeededOrWait();
}
if (
dataStorageAvailable &&
stores.preferences &&
stores.preferences.loaded &&
/^skip$/i.test(stores.preferences.nfsSensitivePolicy) &&
payload &&
payload.params &&
payload.params[CP_CAP_LIMIT_MOUNTS] &&
payload.params[CP_CAP_LIMIT_MOUNTS].value &&
!/^none$/i.test(payload.params[CP_CAP_LIMIT_MOUNTS].value)
) {
dataStorageAvailable && await dataStorageAvailable.fetchIfNeededOrWait();
if (dataStorageAvailable.loaded) {
const cpCapLimitMountsParameter = payload.params[CP_CAP_LIMIT_MOUNTS].value || '';
const selection = getLimitMountsStorages(
cpCapLimitMountsParameter,
dataStorageAvailable.value || []
);
const hasSensitive = !!selection.find(s => s.sensitive);
const filtered = selection
.filter(
filterNFSStorages(
stores.preferences.nfsSensitivePolicy,
hasSensitive
)
);
if (filtered.length) {
payload.params[CP_CAP_LIMIT_MOUNTS].value = getLimitMountsParameterValue(
filtered,
cpCapLimitMountsParameter
);
} else {
payload.params[CP_CAP_LIMIT_MOUNTS].value = 'None';
}
}
}
if (stores.awsRegions) {
await stores.awsRegions.fetchIfNeededOrWait();
}
if (payload.pipelineId) {
const {pipelines} = stores;
await pipelines.fetchIfNeededOrWait();
const [pipeline] = (pipelines.value || []).filter(p => `${p.id}` === `${payload.pipelineId}`);
if (pipeline) {
launchName = pipeline.name;
}
} else {
const [, , imageName] = payload.dockerImage.split('/');
const parts = imageName.split(':');
if (parts.length === 2) {
launchName = parts[0];
launchVersion = parts[1];
} else {
launchName = imageName;
}
}
let scheduleRules = null;
if (payload.scheduleRules && payload.scheduleRules.length > 0) {
scheduleRules = payload.scheduleRules;
delete payload.scheduleRules;
}
payload.params = applyCustomCapabilitiesParameters(payload.params, stores.preferences);
const launchFn = async () => {
const messageVersion = payload.runNameAlias
? `${launchName}:${launchVersion}`
: launchVersion;
const hide = message
.loading(`Launching ${payload.runNameAlias || launchName} (${messageVersion})...`, -1);
if (payload.runNameAlias) {
payload.tags = {
alias: payload.runNameAlias
};
delete payload.runNameAlias;
}
await PipelineRunner.send({...payload, force: true});
hide();
if (PipelineRunner.error) {
message.error(PipelineRunner.error);
resolve(false);
callbackFn && callbackFn(false);
} else {
if (scheduleRules && scheduleRules.length > 0) {
await saveRunSchedule(PipelineRunner.value.id, scheduleRules);
}
await runHostedApp(PipelineRunner.value.id, hostedApplicationConfiguration);
resolve(true);
callbackFn && callbackFn(true);
}
};
if (!confirm) {
await launchFn();
} else {
const inputs = getInputPaths(null, payload.params);
const outputs = getOutputPaths(null, payload.params);
const {errors: permissionErrors} = await performAsyncCheck({
...stores,
dataStorages: dataStorageAvailable,
inputs,
outputs,
dockerImage: payload.dockerImage,
skipCheck
});
let dataStorages;
if (dataStorageAvailable) {
await dataStorageAvailable.fetchIfNeededOrWait();
if (dataStorageAvailable.loaded) {
dataStorages = (dataStorageAvailable.value || []).map(d => d);
}
}
let component;
const ref = (element) => {
component = element;
};
const hide = message.loading('Checking tool size...', 0);
const versionErrors = await checkToolVersionErrors(
payload.dockerImage,
stores.preferences,
stores.dockerRegistries
);
hide();
RunModal.open({
title: null,
width: '50%',
okDisabled: versionErrors.size.hard,
content: (
<RunSpotConfirmationWithPrice
runInfo={{
name: launchName,
alias: payload.runNameAlias,
version: launchVersion,
title,
payload
}}
ref={ref}
platform={platform}
warning={warning}
versionErrors={versionErrors}
instanceType={payload.instanceType}
hddSize={payload.hddSize}
isSpot={payload.isSpot}
isCluster={payload.nodeCount > 0 || autoScaledClusterEnabled(payload.params)}
onDemandSelectionAvailable={availablePriceTypes.indexOf(false) >= 0}
pipelineId={payload.pipelineId}
pipelineVersion={payload.version}
pipelineConfiguration={payload.configurationName}
nodeCount={(+payload.nodeCount) || 0}
cloudRegionId={payload.cloudRegionId}
cloudRegions={(stores.awsRegions.value || []).map(p => p)}
availableInstanceTypes={availableInstanceTypes}
dataStorages={dataStorages}
parameters={payload.params}
permissionErrors={permissionErrors}
limitMounts={
payload.params && payload.params[CP_CAP_LIMIT_MOUNTS]
? payload.params[CP_CAP_LIMIT_MOUNTS].value
: undefined
}
preferences={stores.preferences}
dockerRegistries={stores.dockerRegistries}
usersInfo={stores.usersInfo}
skipCheck={skipCheck}
dockerImage={payload.dockerImage}
authenticatedUserInfo={authenticatedUserInfo}
/>
),
style: {
wordWrap: 'break-word'
},
closable: false,
okText: 'Launch',
onOk: async function () {
if (component) {
if (component.state.runCapabilities) {
payload.params = updateCapabilities(
payload.params,
component.state.runCapabilities,
stores.preferences
);
}
payload.params = applyCustomCapabilitiesParameters(
payload.params,
stores.preferences
);
if (
checkRequiredCapabilitiesErrors(
getEnabledCapabilities(payload.params),
stores.preferences
)
) {
const error = 'You need to specify required capabilities';
message.error(error, 5);
return Promise.reject(new Error(error));
}
payload.isSpot = component.state.isSpot;
payload.instanceType = component.state.instanceType;
payload.hddSize = component.state.hddSize;
if (component.state.limitMounts !== component.props.limitMounts) {
const {limitMounts} = component.state;
if (limitMounts) {
if (!payload.params) {
payload.params = {};
}
payload.params[CP_CAP_LIMIT_MOUNTS] = {
type: 'string',
required: false,
value: limitMounts
};
} else if (payload.params && payload.params[CP_CAP_LIMIT_MOUNTS]) {
delete payload.params[CP_CAP_LIMIT_MOUNTS];
}
}
if (component.state.runNameAlias) {
payload.tags = {
alias: component.state.runNameAlias
};
}
}
if (!payload.instanceType) {
message.error('You should select instance type');
resolve(false);
callbackFn && callbackFn(false);
} else {
const version = payload.runNameAlias
? `${launchName}:${launchVersion}`
: launchVersion;
const hide = message
.loading(`Launching ${payload.runNameAlias || launchName} (${version})...`, -1);
if (payload.runNameAlias) {
delete payload.runNameAlias;
}
await PipelineRunner.send({...payload, force: true});
hide();
if (PipelineRunner.error) {
message.error(PipelineRunner.error);
resolve(false);
callbackFn && callbackFn(false);
} else {
if (scheduleRules && scheduleRules.length > 0) {
await saveRunSchedule(PipelineRunner.value.id, scheduleRules);
}
await runHostedApp(PipelineRunner.value.id, hostedApplicationConfiguration);
resolve(true);
callbackFn && callbackFn(true);
}
}
},
onCancel () {
resolve(false);
callbackFn && callbackFn(false);
}
});
}
});
}